palmier 0.8.9 → 0.8.11

package/README.md

@@ -110,14 +110,15 @@ All device tools work while the Palmier Android app is in the background — the
 
 ## Access Modes
 
-Two modes — Local always works on the host machine; Server pairs other devices through the cloud relay.
+Three ways to reach your host, ordered by setup effort:
 
-| Mode | URL | Pairing | Notes |
-|------|-----|---------|-------|
-| **Local** | `http://localhost:<port>` | Not required | Loopback only — open in a browser on the host machine. No internet needed. |
-| **Server** | [https://app.palmier.me](https://app.palmier.me) | Required | Pair the device with a one-time code. Push notifications, remote access from anywhere. |
+| Mode | Where | Pairing | Notes |
+|------|-------|---------|-------|
+| **Local** | `http://localhost:<port>` in a browser on the host machine | Not required | Loopback only. No internet needed. |
+| **Remote (web)** | [https://app.palmier.me](https://app.palmier.me) in any browser | Required | Always goes through the cloud relay. |
+| **Remote (app)** | [Android APK](https://github.com/caihongxu/palmier-android/releases) | Required | Push notifications, background device capabilities, and **auto-LAN**. |
 
-**Auto-LAN (native app only).** When the Capacitor Android app is on the same network as the host, it transparently routes RPC over direct LAN HTTP (`http://<host-ip>:<port>/rpc/...`) instead of through the relay — lower latency, no protocol change. Events still flow over the relay. Browser PWAs can't do this and stay on the relay.
+**Auto-LAN (native app only).** When the Android app is on the same network as the host, it transparently routes RPC over direct LAN HTTP (`http://<host-ip>:<port>/rpc/...`) instead of through the relay — lower latency, no protocol change. Events still flow over the relay. Pairing always goes through the relay regardless. Browser PWAs can't do this (Private Network Access / mixed-content restrictions) and stay on the relay.
 
 ## Security & Privacy
 
@@ -135,7 +136,7 @@ In all modes, client tokens are generated and validated entirely on your host. T
 
 Local access (`http://localhost:<port>`) works immediately — no pairing needed.
 
-For other devices, run `palmier pair` on the host to generate a code, then enter it at [https://app.palmier.me](https://app.palmier.me). Pairing always goes through the relay; auto-LAN kicks in transparently afterward when the device is on the same network.
+For remote access (web or app), run `palmier pair` on the host to generate a code, then enter it at [https://app.palmier.me](https://app.palmier.me) or in the Android app. Pairing always goes through the relay; auto-LAN kicks in transparently afterward in the native app when on the same network.
 
 ### Managing Clients
 
@@ -155,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)
@@ -166,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/info.js

@@ -1,10 +1,15 @@
 import { loadConfig } from "../config.js";
 import { loadClients } from "../client-store.js";
+import { buildLanUrl } from "../network.js";
 export async function infoCommand() {
     const config = loadConfig();
     const clients = loadClients();
+    const port = config.httpPort ?? 7256;
+    const lanUrl = buildLanUrl(port, config.defaultInterface);
     console.log(`Host ID:      ${config.hostId}`);
     console.log(`Project root: ${config.projectRoot}`);
+    console.log(`Local URL:    http://localhost:${port}`);
+    console.log(`LAN URL:      ${lanUrl ?? "(default route interface unavailable — pair a device or check network)"}`);
     if (config.agents && config.agents.length > 0) {
         console.log(`Agents:       ${config.agents.map((a) => a.label).join(", ")}`);
     }

package/dist/commands/init.js

@@ -3,7 +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 { detectLanIp } from "../transports/http-transport.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`;
@@ -32,15 +32,25 @@ export async function initCommand() {
         const parsed = parseInt(portAnswer.trim(), 10);
         if (parsed > 0 && parsed < 65536)
             httpPort = parsed;
-        const lanIp = detectLanIp();
+        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`);
-        console.log(`  ${dim("Local access:")}   ${cyan(`http://localhost:${httpPort}`)}`);
+        console.log(`  ${dim("Local:")}          ${cyan(`http://localhost:${httpPort}`)}`);
         console.log(`                  Open in a browser on this machine — no internet required.\n`);
-        console.log(`  ${dim("Remote access:")}  ${cyan("https://app.palmier.me")}`);
-        console.log(`                  Pair the app to your host. The app uses ${cyan(`http://${lanIp}:${httpPort}`)}`);
-        console.log(`                  for direct RPC when on the same network, otherwise the relay.\n`);
+        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")}`);
+        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

@@ -4,7 +4,6 @@ import { StringCodec } from "nats";
 import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
 import { addClient } from "../client-store.js";
-import { detectLanIp } from "../transports/http-transport.js";
 const CODE_CHARS = "ABCDEFGHJKMNPQRSTUVWXYZ23456789"; // no O/0/I/1/L
 const CODE_LENGTH = 6;
 export const PAIRING_EXPIRY_MS = 60 * 1000; // 1 minute
@@ -15,11 +14,9 @@ export function generatePairingCode() {
 }
 function buildPairResponse(config, label) {
     const client = addClient(label);
-    const port = config.httpPort ?? 7256;
     return {
         hostId: config.hostId,
         clientToken: client.token,
-        directUrl: `http://${detectLanIp()}:${port}`,
         hostName: os.hostname(),
     };
 }

package/dist/network.d.ts

@@ -0,0 +1,4 @@
+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;
+//# sourceMappingURL=network.d.ts.map

package/dist/network.js

@@ -0,0 +1,100 @@
+import * as os from "node:os";
+import * as dgram from "node:dgram";
+/**
+ * Resolve the name of the network interface used for the IPv4 default route.
+ * 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() {
+    const probedIp = await probeOutboundIp();
+    if (probedIp) {
+        const name = findInterfaceByIp(probedIp);
+        if (name && !isVirtualName(name))
+            return name;
+    }
+    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];
+    if (!addrs)
+        return null;
+    for (const addr of addrs) {
+        if (addr.family === "IPv4" && !addr.internal)
+            return addr.address;
+    }
+    return null;
+}
+export function buildLanUrl(port, interfaceName) {
+    if (!interfaceName)
+        return null;
+    const ip = getInterfaceIpv4(interfaceName);
+    return ip ? `http://${ip}:${port}` : null;
+}
+//# sourceMappingURL=network.js.map