palmier 0.8.9 → 0.8.10

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
 

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,6 @@ 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 { listTasks } from "../task.js";
 const bold = (s) => `\x1b[1m${s}\x1b[0m`;
 const dim = (s) => `\x1b[2m${s}\x1b[0m`;
@@ -32,15 +31,16 @@ export async function initCommand() {
         const parsed = parseInt(portAnswer.trim(), 10);
         if (parsed > 0 && parsed < 65536)
             httpPort = parsed;
-        const lanIp = detectLanIp();
         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")}`);
+        console.log(`                  Download the Android APK. The app uses LAN for direct RPC`);
+        console.log(`                  when on the same network, otherwise the relay.\n`);
         console.log(`  ${dim("Agents:")}         ${agents.map((a) => a.label).join(", ")}\n`);
         const existingTasks = listTasks(process.cwd());
         if (existingTasks.length > 0) {

package/dist/commands/pair.js

@@ -1,10 +1,10 @@
 import * as http from "node:http";
 import * as os from "node:os";
 import { StringCodec } from "nats";
-import { loadConfig } from "../config.js";
+import { loadConfig, saveConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
 import { addClient } from "../client-store.js";
-import { detectLanIp } from "../transports/http-transport.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 +13,16 @@ export function generatePairingCode() {
     crypto.getRandomValues(bytes);
     return Array.from(bytes, (b) => CODE_CHARS[b % CODE_CHARS.length]).join("");
 }
-function buildPairResponse(config, label) {
+async function buildPairResponse(config, label) {
     const client = addClient(label);
-    const port = config.httpPort ?? 7256;
+    const iface = await detectDefaultInterface();
+    if (iface && iface !== config.defaultInterface) {
+        config.defaultInterface = iface;
+        saveConfig(config);
+    }
     return {
         hostId: config.hostId,
         clientToken: client.token,
-        directUrl: `http://${detectLanIp()}:${port}`,
         hostName: os.hostname(),
     };
 }
@@ -88,7 +91,7 @@ export async function pairCommand() {
                 }
             }
             catch { /* empty body is fine */ }
-            const response = buildPairResponse(config, label);
+            const response = await buildPairResponse(config, label);
             if (msg.reply) {
                 msg.respond(sc.encode(JSON.stringify(response)));
             }

package/dist/network.d.ts

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

package/dist/network.js

@@ -0,0 +1,34 @@
+import * as os from "node:os";
+// @ts-expect-error - default-gateway ships no types
+import { gateway4async } from "default-gateway";
+/**
+ * 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 async function detectDefaultInterface() {
+    try {
+        const result = await gateway4async();
+        return result.int ?? null;
+    }
+    catch {
+        return 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