palmier 0.8.10 → 0.8.11

package/README.md

@@ -156,6 +156,7 @@ palmier clients revoke-all
 The wizard:
 - Detects installed agent CLIs and caches the result
 - Asks for the HTTP port
+- Detects the default network interface (used for auto-LAN)
 - Shows a summary (including any existing scheduled tasks to recover) and asks for confirmation
 - Registers with the Palmier server, saves configuration to `~/.config/palmier/host.json`
 - Installs a background daemon (systemd user service on Linux, LaunchAgent on macOS, Task Scheduler on Windows)
@@ -167,6 +168,10 @@ The daemon automatically recovers existing tasks by reinstalling their system ti
 
 Agents are re-detected on every daemon start. Run `palmier restart` after installing or removing a CLI.
 
+### Re-detecting the LAN Network
+
+The default network interface is detected once during `palmier init` and saved to `host.json`. The daemon derives the current IP live from that interface on each client connect, so DHCP-assigned IP changes on the same adapter are picked up automatically. If you physically switch to a different network adapter (e.g., plug in Ethernet after running on WiFi, or add a new USB-tethered interface), run `palmier init` again to re-detect.
+
 ## CLI Reference
 
 | Command | Description |

package/dist/commands/init.js

@@ -3,6 +3,7 @@ import { loadConfig, saveConfig } from "../config.js";
 import { detectAgents } from "../agents/agent.js";
 import { getPlatform } from "../platform/index.js";
 import { pairCommand } from "./pair.js";
+import { detectDefaultInterface, getInterfaceIpv4 } from "../network.js";
 import { listTasks } from "../task.js";
 const bold = (s) => `\x1b[1m${s}\x1b[0m`;
 const dim = (s) => `\x1b[2m${s}\x1b[0m`;
@@ -31,6 +32,8 @@ export async function initCommand() {
         const parsed = parseInt(portAnswer.trim(), 10);
         if (parsed > 0 && parsed < 65536)
             httpPort = parsed;
+        const defaultInterface = (await detectDefaultInterface()) ?? undefined;
+        const lanIp = defaultInterface ? getInterfaceIpv4(defaultInterface) : null;
         console.log(`\n${bold("Setup summary:")}\n`);
         console.log(`  ${dim("Task storage:")}   ${bold(process.cwd())}`);
         console.log(`                  All tasks and execution data will be stored here.\n`);
@@ -39,8 +42,15 @@ export async function initCommand() {
         console.log(`  ${dim("Remote (web):")}   ${cyan("https://app.palmier.me")}`);
         console.log(`                  Pair a browser on any device. Traffic always goes through the relay.\n`);
         console.log(`  ${dim("Remote (app):")}   ${cyan("https://github.com/caihongxu/palmier-android/releases")}`);
-        console.log(`                  Download the Android APK. The app uses LAN for direct RPC`);
-        console.log(`                  when on the same network, otherwise the relay.\n`);
+        if (lanIp) {
+            console.log(`                  Download the Android APK. The app uses LAN for direct RPC`);
+            console.log(`                  on the same network (detected ${cyan(`http://${lanIp}:${httpPort}`)}),`);
+            console.log(`                  otherwise the relay.\n`);
+        }
+        else {
+            console.log(`                  Download the Android APK. Traffic will go through the relay —`);
+            console.log(`                  ${red("could not detect a LAN interface")} for direct RPC.\n`);
+        }
         console.log(`  ${dim("Agents:")}         ${agents.map((a) => a.label).join(", ")}\n`);
         const existingTasks = listTasks(process.cwd());
         if (existingTasks.length > 0) {
@@ -89,6 +99,7 @@ export async function initCommand() {
             natsNkeySeed: registerResponse.natsNkeySeed,
             agents,
             httpPort,
+            defaultInterface,
         };
         saveConfig(config);
         console.log(`Config saved to ${dim("~/.config/palmier/host.json")}`);

package/dist/commands/pair.js

@@ -1,10 +1,9 @@
 import * as http from "node:http";
 import * as os from "node:os";
 import { StringCodec } from "nats";
-import { loadConfig, saveConfig } from "../config.js";
+import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
 import { addClient } from "../client-store.js";
-import { detectDefaultInterface } from "../network.js";
 const CODE_CHARS = "ABCDEFGHJKMNPQRSTUVWXYZ23456789"; // no O/0/I/1/L
 const CODE_LENGTH = 6;
 export const PAIRING_EXPIRY_MS = 60 * 1000; // 1 minute
@@ -13,13 +12,8 @@ export function generatePairingCode() {
     crypto.getRandomValues(bytes);
     return Array.from(bytes, (b) => CODE_CHARS[b % CODE_CHARS.length]).join("");
 }
-async function buildPairResponse(config, label) {
+function buildPairResponse(config, label) {
     const client = addClient(label);
-    const iface = await detectDefaultInterface();
-    if (iface && iface !== config.defaultInterface) {
-        config.defaultInterface = iface;
-        saveConfig(config);
-    }
     return {
         hostId: config.hostId,
         clientToken: client.token,
@@ -91,7 +85,7 @@ export async function pairCommand() {
                 }
             }
             catch { /* empty body is fine */ }
-            const response = await buildPairResponse(config, label);
+            const response = buildPairResponse(config, label);
             if (msg.reply) {
                 msg.respond(sc.encode(JSON.stringify(response)));
             }

package/dist/network.d.ts

@@ -1,8 +1,3 @@
-/**
- * Resolve the name of the network interface used for the IPv4 default route.
- * Returns null when no default route is found (e.g. fully offline host) or
- * when the OS platform isn't supported by `default-gateway`.
- */
 export declare function detectDefaultInterface(): Promise<string | null>;
 export declare function getInterfaceIpv4(interfaceName: string): string | null;
 export declare function buildLanUrl(port: number, interfaceName: string | undefined): string | null;

package/dist/network.js

@@ -1,19 +1,85 @@
 import * as os from "node:os";
-// @ts-expect-error - default-gateway ships no types
-import { gateway4async } from "default-gateway";
+import * as dgram from "node:dgram";
 /**
  * Resolve the name of the network interface used for the IPv4 default route.
- * Returns null when no default route is found (e.g. fully offline host) or
- * when the OS platform isn't supported by `default-gateway`.
+ * Falls back to the first non-internal IPv4 interface when the gateway lookup
+ * fails — `default-gateway` shells out to `wmic` on Windows, which was removed
+ * in Windows 11 24H2.
  */
+function findInterfaceByIp(ip) {
+    for (const [name, addrs] of Object.entries(os.networkInterfaces())) {
+        for (const addr of addrs ?? []) {
+            if (addr.family === "IPv4" && addr.address === ip)
+                return name;
+        }
+    }
+    return null;
+}
+/** Ask the kernel which local IPv4 would route to an external address. No packet is sent. */
+function probeOutboundIp() {
+    return new Promise((resolve) => {
+        const sock = dgram.createSocket("udp4");
+        const cleanup = (ip) => { try {
+            sock.close();
+        }
+        catch { /* ignore */ } resolve(ip); };
+        sock.on("error", () => cleanup(null));
+        try {
+            sock.connect(80, "8.8.8.8", () => {
+                const addr = sock.address();
+                cleanup(addr.address && addr.address !== "0.0.0.0" ? addr.address : null);
+            });
+        }
+        catch {
+            cleanup(null);
+        }
+    });
+}
+/** Lower score = more preferred. 0=192.168, 1=10.x, 2=172.16-31, 3=everything else. */
+function ipClass(ip) {
+    const parts = ip.split(".").map(Number);
+    if (parts.length !== 4 || parts.some((p) => Number.isNaN(p)))
+        return 3;
+    const [a, b] = parts;
+    if (a === 192 && b === 168)
+        return 0;
+    if (a === 10)
+        return 1;
+    if (a === 172 && b >= 16 && b <= 31)
+        return 2;
+    return 3;
+}
+/** Names that commonly belong to virtual/VPN adapters we'd rather skip. */
+const VIRTUAL_NAME_PATTERNS = [
+    "vethernet", "virtualbox", "vmware", "hyper-v", "docker", "bridge",
+    "tailscale", "wireguard", "meta", "vpn", "tun", "tap", "loopback",
+    "wsl", "utun",
+];
+function isVirtualName(name) {
+    const lower = name.toLowerCase();
+    return VIRTUAL_NAME_PATTERNS.some((p) => lower.includes(p));
+}
 export async function detectDefaultInterface() {
-    try {
-        const result = await gateway4async();
-        return result.int ?? null;
+    const probedIp = await probeOutboundIp();
+    if (probedIp) {
+        const name = findInterfaceByIp(probedIp);
+        if (name && !isVirtualName(name))
+            return name;
     }
-    catch {
-        return null;
+    const candidates = [];
+    for (const [name, addrs] of Object.entries(os.networkInterfaces())) {
+        for (const addr of addrs ?? []) {
+            if (addr.family !== "IPv4" || addr.internal)
+                continue;
+            candidates.push({ name, klass: ipClass(addr.address), virtual: isVirtualName(name) });
+        }
     }
+    candidates.sort((a, b) => {
+        if (a.virtual !== b.virtual)
+            return a.virtual ? 1 : -1;
+        return a.klass - b.klass;
+    });
+    return candidates[0]?.name ?? null;
 }
 export function getInterfaceIpv4(interfaceName) {
     const addrs = os.networkInterfaces()[interfaceName];