palmier 0.8.9 → 0.8.11

package/palmier-server/pwa/src/contexts/HostConnectionContext.tsx

@@ -103,18 +103,27 @@ export function HostConnectionProvider({ children }: { children: ReactNode }) {
     const expectedHostId = activeHost.hostId;
 
     async function probe() {
+      console.log("[HOST/LAN] probing", lanUrl);
       try {
         const res = await fetch(`${lanUrl}/health`, {
           signal: AbortSignal.timeout(LAN_PROBE_TIMEOUT_MS),
         });
         if (cancelled) return;
-        if (!res.ok) { setLanReachable(false); return; }
+        if (!res.ok) {
+          console.log("[HOST/LAN] probe got non-ok:", res.status);
+          setLanReachable(false);
+          return;
+        }
         const data = await res.json() as { hostId?: string };
         const reachable = data.hostId === expectedHostId;
+        if (!reachable) console.log("[HOST/LAN] hostId mismatch — got:", data.hostId, "expected:", expectedHostId);
+        else console.log("[HOST/LAN] reachable");
         setLanReachable(reachable);
-        if (reachable) console.log("[HOST/LAN] reachable:", lanUrl);
-      } catch {
-        if (!cancelled) setLanReachable(false);
+      } catch (err) {
+        if (!cancelled) {
+          console.log("[HOST/LAN] probe failed:", err instanceof Error ? err.message : err);
+          setLanReachable(false);
+        }
       }
     }
 

package/palmier-server/pwa/src/contexts/HostStoreContext.tsx

@@ -14,6 +14,7 @@ interface HostStoreContextValue {
   addPairedHost(host: PairedHost): void;
   removePairedHost(hostId: string): void;
   renamePairedHost(hostId: string, name: string): void;
+  setHostLanUrl(hostId: string, lanUrl: string | undefined): void;
   setActiveHostId(hostId: string): void;
   getActiveHost(): PairedHost | null;
 }
@@ -113,6 +114,16 @@ export function HostStoreProvider({ children }: { children: ReactNode }) {
     );
   }, []);
 
+  const setHostLanUrl = useCallback((hostId: string, lanUrl: string | undefined) => {
+    setPairedHosts((prev) =>
+      prev.map((h) => {
+        if (h.hostId !== hostId) return h;
+        if (h.lanUrl === lanUrl) return h;
+        return { ...h, lanUrl };
+      })
+    );
+  }, []);
+
   const setActiveHostId = useCallback((hostId: string) => {
     setActiveHostIdState(hostId);
   }, []);
@@ -128,6 +139,7 @@ export function HostStoreProvider({ children }: { children: ReactNode }) {
       addPairedHost,
       removePairedHost,
       renamePairedHost,
+      setHostLanUrl,
       setActiveHostId,
       getActiveHost,
     }}>

package/palmier-server/pwa/src/pages/Dashboard.tsx

@@ -45,7 +45,7 @@ interface PermissionPrompt { permissions: RequiredPermission[]; sessionName?: st
 interface InputPrompt { questions: string[]; description?: string; sessionName?: string }
 
 export default function Dashboard() {
-  const { pairedHosts, activeHostId, removePairedHost } = useHostStore();
+  const { pairedHosts, activeHostId, removePairedHost, setHostLanUrl } = useHostStore();
   const { connected, request, subscribeEvents, unauthorized } = useHostConnection();
   const navigate = useNavigate();
   const location = useLocation();
@@ -90,6 +90,7 @@ export default function Dashboard() {
       host_platform?: string;
       capability_tokens?: Record<string, string | null>;
       pending_prompts?: PendingPrompt[];
+      lan_url?: string | null;
     }>("host.info")
       .then((result) => {
         setAgents(result.agents ?? []);
@@ -99,6 +100,9 @@ export default function Dashboard() {
         const version = result.version ?? null;
         setDaemonVersion(version);
         setUpdateRequired(!!version && isOlderThan(version, MIN_HOST_VERSION));
+        if (activeHostId) {
+          setHostLanUrl(activeHostId, result.lan_url ?? undefined);
+        }
 
         // Seed modal state from already-pending prompts.
         const confirms = new Map<string, ConfirmPrompt>();
@@ -132,7 +136,7 @@ export default function Dashboard() {
         setInputValues(inputVals);
       })
       .catch(() => { /* silent — update-required prompt guards the broken case */ });
-  }, [connected, activeHostId, request]);
+  }, [connected, activeHostId, request, setHostLanUrl]);
 
   // Always-on event subscription for modal lifecycle. Independent of which tab
   // is active. Task-card status updates happen inside TasksView while mounted.

package/palmier-server/pwa/src/pages/PairHost.tsx

@@ -11,7 +11,6 @@ import type { PairedHost } from "../types";
 interface PairResponse {
   hostId: string;
   clientToken: string;
-  directUrl?: string;
   hostName?: string;
 }
 
@@ -82,7 +81,6 @@ export default function PairHost() {
         hostId: response.hostId,
         clientToken: response.clientToken,
         directUrl: isLoopback ? window.location.origin : undefined,
-        lanUrl: !isLoopback ? response.directUrl : undefined,
         ...(response.hostName ? { name: response.hostName } : {}),
       };
 

package/palmier-server/pwa/src/pages/PairSetup.tsx

@@ -6,12 +6,13 @@ import CapabilityToggles from "../components/CapabilityToggles";
 
 interface HostInfoResponse {
   capability_tokens?: Record<string, string | null>;
+  lan_url?: string | null;
 }
 
 export default function PairSetup() {
   const navigate = useNavigate();
   const { connected, request } = useHostConnection();
-  const { getActiveHost } = useHostStore();
+  const { getActiveHost, setHostLanUrl } = useHostStore();
   const activeHost = getActiveHost();
   const activeClientToken = activeHost?.clientToken ?? null;
 
@@ -26,16 +27,18 @@ export default function PairSetup() {
 
   useEffect(() => {
     if (!connected || !activeHost) return;
+    const activeHostId = activeHost.hostId;
     let cancelled = false;
     request<HostInfoResponse>("host.info")
       .then((res) => {
         if (cancelled) return;
         setCapabilityTokens(res.capability_tokens ?? {});
+        setHostLanUrl(activeHostId, res.lan_url ?? undefined);
         setLoaded(true);
       })
       .catch(() => { if (!cancelled) setLoaded(true); });
     return () => { cancelled = true; };
-  }, [connected, activeHost, request]);
+  }, [connected, activeHost, request, setHostLanUrl]);
 
   return (
     <div className="pair-setup">

package/palmier-server/pwa/src/types.ts

@@ -66,6 +66,6 @@ export interface PairedHost {
   name?: string;
   /** If set, all communication uses HTTP to this URL instead of NATS. Set only for loopback (Local mode). */
   directUrl?: string;
-  /** Host's LAN URL captured at pair time. Native Capacitor app probes for reachability and routes RPC over HTTP when reachable; events stay on NATS. */
+  /** Host's LAN URL, refreshed from each `host.info` response so laptop/DHCP IP changes propagate. Native Capacitor app probes for reachability and routes RPC over HTTP when reachable; events stay on NATS. */
   lanUrl?: string;
 }

package/palmier-server/spec.md

@@ -91,13 +91,16 @@ Each host machine is provisioned via `palmier init`, an interactive wizard that
 
 1. Detects installed agent CLIs.
 2. Asks which HTTP port to use (default 7256).
-3. Shows a summary of task storage directory, local access URL, detected agents, and any existing tasks to recover. Asks for confirmation before proceeding.
-4. Registers with the Palmier server via `POST <url>/api/hosts/register` — server returns `{ hostId, natsUrl, natsWsUrl, natsJwt, natsNkeySeed }`.
-5. Saves config to `~/.config/palmier/host.json` (includes `httpPort`, NATS credentials).
-6. Installs a systemd user service (Linux), user LaunchAgent (macOS), or Task Scheduler entry (Windows) and auto-enters pair mode.
+3. Detects the OS default network interface (used as the source for the host's LAN URL in `host.info` responses).
+4. Shows a summary of task storage directory, local access URL, detected agents, and any existing tasks to recover. Asks for confirmation before proceeding.
+5. Registers with the Palmier server via `POST <url>/api/hosts/register` — server returns `{ hostId, natsUrl, natsWsUrl, natsJwt, natsNkeySeed }`.
+6. Saves config to `~/.config/palmier/host.json` (includes `httpPort`, `defaultInterface`, NATS credentials).
+7. Installs a systemd user service (Linux), user LaunchAgent (macOS), or Task Scheduler entry (Windows) and auto-enters pair mode.
 
 The daemon automatically recovers existing tasks by reinstalling their system timers on startup.
 
+`defaultInterface` is captured once at `init` time. On each `host.info` RPC, the host re-reads the current IPv4 of that interface (`getInterfaceIpv4(config.defaultInterface)`) so DHCP-assigned IP changes on the same adapter propagate to clients without a re-pair. Users should re-run `palmier init` if they physically switch adapters (e.g., Ethernet ↔ WiFi, adding a new tethered interface).
+
 The `serve` daemon always starts an HTTP server bound to `0.0.0.0:<port>`. Two access modes are available:
 
 **Local mode** (always available, loopback only):

package/src/commands/info.ts

@@ -1,12 +1,18 @@
 import { loadConfig } from "../config.js";
 import { loadClients } from "../client-store.js";
+import { buildLanUrl } from "../network.js";
 
 export async function infoCommand(): Promise<void> {
   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/src/commands/init.ts

@@ -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";
 import type { HostConfig } from "../types.js";
 
@@ -42,16 +42,25 @@ export async function initCommand(): Promise<void> {
     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());
@@ -102,6 +111,7 @@ export async function initCommand(): Promise<void> {
       natsNkeySeed: registerResponse.natsNkeySeed,
       agents,
       httpPort,
+      defaultInterface,
     };
 
     saveConfig(config);

package/src/commands/pair.ts

@@ -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";
 import type { HostConfig } from "../types.js";
 
 const CODE_CHARS = "ABCDEFGHJKMNPQRSTUVWXYZ23456789"; // no O/0/I/1/L
@@ -20,11 +19,9 @@ export function generatePairingCode(): string {
 
 function buildPairResponse(config: HostConfig, label?: string) {
   const client = addClient(label);
-  const port = config.httpPort ?? 7256;
   return {
     hostId: config.hostId,
     clientToken: client.token,
-    directUrl: `http://${detectLanIp()}:${port}`,
     hostName: os.hostname(),
   };
 }

package/src/network.ts

@@ -0,0 +1,96 @@
+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: string): string | null {
+  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(): Promise<string | null> {
+  return new Promise((resolve) => {
+    const sock = dgram.createSocket("udp4");
+    const cleanup = (ip: string | null) => { 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);
+    }
+  });
+}
+
+type IpClass = 0 | 1 | 2 | 3;
+
+/** Lower score = more preferred. 0=192.168, 1=10.x, 2=172.16-31, 3=everything else. */
+function ipClass(ip: string): IpClass {
+  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: string): boolean {
+  const lower = name.toLowerCase();
+  return VIRTUAL_NAME_PATTERNS.some((p) => lower.includes(p));
+}
+
+export async function detectDefaultInterface(): Promise<string | null> {
+  const probedIp = await probeOutboundIp();
+  if (probedIp) {
+    const name = findInterfaceByIp(probedIp);
+    if (name && !isVirtualName(name)) return name;
+  }
+
+  type Candidate = { name: string; klass: IpClass; virtual: boolean };
+  const candidates: Candidate[] = [];
+  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: string): string | null {
+  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: number, interfaceName: string | undefined): string | null {
+  if (!interfaceName) return null;
+  const ip = getInterfaceIpv4(interfaceName);
+  return ip ? `http://${ip}:${port}` : null;
+}

package/src/rpc-handler.ts

@@ -15,6 +15,7 @@ import { getCapabilityDevice, setCapabilityDevice, clearCapabilityDevice, type D
 import { currentVersion, performUpdate } from "./update-checker.js";
 import { parseReportFiles, parseTaskOutcome, stripPalmierMarkers } from "./commands/run.js";
 import { clearTaskQueue } from "./event-queues.js";
+import { buildLanUrl } from "./network.js";
 import type { HostConfig, ParsedTask, RpcMessage, ConversationMessage } from "./types.js";
 
 export function parseResultFrontmatter(raw: string): Record<string, unknown> {
@@ -153,6 +154,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
           host_platform: process.platform,
           capability_tokens: capabilities,
           pending_prompts: listPending(),
+          lan_url: buildLanUrl(config.httpPort ?? 7256, config.defaultInterface),
         };
       }
 

package/src/transports/http-transport.ts

@@ -6,6 +6,8 @@ import { validateClient, addClient } from "../client-store.js";
 import { registerPending } from "../pending-requests.js";
 import * as fs from "node:fs";
 import type { HostConfig, RpcMessage, RequiredPermission } from "../types.js";
+import { saveConfig } from "../config.js";
+import { detectDefaultInterface } from "../network.js";
 import { agentToolMap, agentResources, ToolError, type ToolContext } from "../mcp-tools.js";
 import { handleMcpRequest, getAgentName, getResourceSubscriptions } from "../mcp-handler.js";
 import { getTaskDir } from "../task.js";
@@ -72,16 +74,12 @@ interface PendingPair {
 
 const pendingPairs = new Map<string, PendingPair>();
 
-export function detectLanIp(): string {
-  const interfaces = os.networkInterfaces();
-  for (const name of Object.keys(interfaces)) {
-    for (const iface of interfaces[name] ?? []) {
-      if (iface.family === "IPv4" && !iface.internal) {
-        return iface.address;
-      }
-    }
+async function persistDefaultInterface(config: HostConfig): Promise<void> {
+  const iface = await detectDefaultInterface();
+  if (iface && iface !== config.defaultInterface) {
+    config.defaultInterface = iface;
+    saveConfig(config);
   }
-  return "127.0.0.1";
 }
 
 export async function startHttpTransport(
@@ -371,11 +369,10 @@ export async function startHttpTransport(
         if (!pending) { sendJson(res, 401, { error: "Invalid code" }); return; }
 
         const client = addClient(label);
-        const ip = detectLanIp();
+        await persistDefaultInterface(config);
         const response: Record<string, unknown> = {
           hostId: config.hostId,
           clientToken: client.token,
-          directUrl: `http://${ip}:${port}`,
           hostName: os.hostname(),
         };
 

package/src/types.ts

@@ -10,6 +10,11 @@ export interface HostConfig {
   agents?: Array<{ key: string; label: string; supportsPermissions: boolean; supportsYolo: boolean }>;
 
   httpPort?: number;
+
+  /** OS network interface name of the IPv4 default route, captured on the
+   * most recent `palmier pair`. Used to resolve the host's LAN URL live for
+   * `host.info` so the client can track IP changes (laptop roaming, DHCP). */
+  defaultInterface?: string;
 }
 
 export interface TaskFrontmatter {