palmier 0.8.10 → 0.9.2

package/README.md

@@ -78,7 +78,7 @@ Palmier exposes an [MCP](https://modelcontextprotocol.io) server at `http://loca
 
 Resources support MCP subscriptions — clients can subscribe via `resources/subscribe` and receive real-time `notifications/resources/updated` events via the streamable HTTP transport when the resource changes.
 
-All device tools work while the Palmier Android app is in the background — they communicate via FCM data messages which wake the app's service even when it's not in the foreground. Permissions listed above must be granted via toggles in the Android app's settings menu.
+All device tools work while the Palmier Android app is in the background — they communicate via FCM data messages which wake the app's service even when it's not in the foreground. Each host has one **linked device**: the phone the host uses for SMS, contacts, location, and other device capabilities. Choose it at pair time (the "Link to this device" checkbox) or later from the drawer. Permissions listed above must be granted via toggles in the linked device's drawer.
 
 ### Architecture
 
@@ -151,11 +151,14 @@ palmier clients revoke <token>
 palmier clients revoke-all
 ```
 
+Revoking the linked device also clears the host's linked-device record; device capabilities stop working until another paired device is linked from its drawer.
+
 ### The `init` Command
 
 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 +170,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/linked-device.d.ts

@@ -0,0 +1,9 @@
+export interface LinkedDevice {
+    clientToken: string;
+    fcmToken: string;
+}
+export declare function getLinkedDevice(): LinkedDevice | null;
+export declare function setLinkedDevice(clientToken: string, fcmToken: string): void;
+export declare function clearLinkedDevice(): void;
+export declare function clearLinkedDeviceIfMatches(clientToken: string): boolean;
+//# sourceMappingURL=linked-device.d.ts.map

package/dist/linked-device.js

@@ -0,0 +1,45 @@
+import * as fs from "fs";
+import * as path from "path";
+import { CONFIG_DIR } from "./config.js";
+const LINKED_DEVICE_FILE = path.join(CONFIG_DIR, "linked-device.json");
+function read() {
+    try {
+        if (!fs.existsSync(LINKED_DEVICE_FILE))
+            return null;
+        const raw = fs.readFileSync(LINKED_DEVICE_FILE, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!parsed?.clientToken || !parsed?.fcmToken)
+            return null;
+        return { clientToken: parsed.clientToken, fcmToken: parsed.fcmToken };
+    }
+    catch {
+        return null;
+    }
+}
+function write(device) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    if (!device) {
+        if (fs.existsSync(LINKED_DEVICE_FILE))
+            fs.unlinkSync(LINKED_DEVICE_FILE);
+        return;
+    }
+    fs.writeFileSync(LINKED_DEVICE_FILE, JSON.stringify(device, null, 2), "utf-8");
+}
+export function getLinkedDevice() {
+    return read();
+}
+export function setLinkedDevice(clientToken, fcmToken) {
+    write({ clientToken, fcmToken });
+}
+export function clearLinkedDevice() {
+    write(null);
+}
+export function clearLinkedDeviceIfMatches(clientToken) {
+    const current = read();
+    if (current?.clientToken === clientToken) {
+        write(null);
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=linked-device.js.map

package/dist/mcp-tools.js

@@ -1,6 +1,6 @@
 import { StringCodec } from "nats";
 import { registerPending } from "./pending-requests.js";
-import { getCapabilityDevice } from "./device-capabilities.js";
+import { getLinkedDevice } from "./linked-device.js";
 import { getNotifications, onNotificationsChanged } from "./notification-store.js";
 import { getSmsMessages, onSmsChanged } from "./sms-store.js";
 export class ToolError extends Error {
@@ -154,9 +154,9 @@ const deviceGeolocationTool = {
     async handler(_args, ctx) {
         if (!ctx.nc)
             throw new ToolError("Not connected to server (NATS unavailable)", 503);
-        const device = getCapabilityDevice("location");
+        const device = getLinkedDevice();
         if (!device)
-            throw new ToolError("No device has location access enabled", 400);
+            throw new ToolError("No linked device configured", 400);
         const sc = StringCodec();
         const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.geolocation`, sc.encode(JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.sessionId, fcmToken: device.fcmToken })), { timeout: 5_000 });
         const ack = JSON.parse(sc.decode(ackReply.data));
@@ -195,9 +195,9 @@ const readContactsTool = {
     async handler(_args, ctx) {
         if (!ctx.nc)
             throw new ToolError("Not connected to server (NATS unavailable)", 503);
-        const device = getCapabilityDevice("contacts");
+        const device = getLinkedDevice();
         if (!device)
-            throw new ToolError("No device has contacts access enabled", 400);
+            throw new ToolError("No linked device configured", 400);
         const sc = StringCodec();
         const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.contacts`, sc.encode(JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.sessionId, fcmToken: device.fcmToken, action: "read" })), { timeout: 5_000 });
         const ack = JSON.parse(sc.decode(ackReply.data));
@@ -241,9 +241,9 @@ const createContactTool = {
     async handler(args, ctx) {
         if (!ctx.nc)
             throw new ToolError("Not connected to server (NATS unavailable)", 503);
-        const device = getCapabilityDevice("contacts");
+        const device = getLinkedDevice();
         if (!device)
-            throw new ToolError("No device has contacts access enabled", 400);
+            throw new ToolError("No linked device configured", 400);
         const { name, phone, email } = args;
         if (!name)
             throw new ToolError("name is required", 400);
@@ -292,9 +292,9 @@ const readCalendarTool = {
     async handler(args, ctx) {
         if (!ctx.nc)
             throw new ToolError("Not connected to server (NATS unavailable)", 503);
-        const device = getCapabilityDevice("calendar");
+        const device = getLinkedDevice();
         if (!device)
-            throw new ToolError("No device has calendar access enabled", 400);
+            throw new ToolError("No linked device configured", 400);
         const { startDate, endDate } = args;
         const sc = StringCodec();
         const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.calendar`, sc.encode(JSON.stringify({
@@ -346,9 +346,9 @@ const createCalendarEventTool = {
     async handler(args, ctx) {
         if (!ctx.nc)
             throw new ToolError("Not connected to server (NATS unavailable)", 503);
-        const device = getCapabilityDevice("calendar");
+        const device = getLinkedDevice();
         if (!device)
-            throw new ToolError("No device has calendar access enabled", 400);
+            throw new ToolError("No linked device configured", 400);
         const { title, startTime, endTime, location, description } = args;
         if (!title || !startTime || !endTime)
             throw new ToolError("title, startTime, and endTime are required", 400);
@@ -400,7 +400,7 @@ const sendSmsTool = {
     async handler(args, ctx) {
         if (!ctx.nc)
             throw new ToolError("Not connected to server (NATS unavailable)", 503);
-        const device = getCapabilityDevice("sms-send");
+        const device = getLinkedDevice();
         if (!device)
             throw new ToolError("No device has SMS Send enabled", 400);
         const { to, body } = args;
@@ -452,9 +452,9 @@ const sendAlarmTool = {
     async handler(args, ctx) {
         if (!ctx.nc)
             throw new ToolError("Not connected to server (NATS unavailable)", 503);
-        const device = getCapabilityDevice("alarm");
+        const device = getLinkedDevice();
         if (!device)
-            throw new ToolError("No device has alarm access enabled", 400);
+            throw new ToolError("No linked device configured", 400);
         const { title, description } = args;
         if (!title)
             throw new ToolError("title is required", 400);
@@ -502,9 +502,9 @@ const readBatteryTool = {
     async handler(_args, ctx) {
         if (!ctx.nc)
             throw new ToolError("Not connected to server (NATS unavailable)", 503);
-        const device = getCapabilityDevice("battery");
+        const device = getLinkedDevice();
         if (!device)
-            throw new ToolError("No device has battery access enabled", 400);
+            throw new ToolError("No linked device configured", 400);
         const sc = StringCodec();
         const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.battery`, sc.encode(JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.sessionId, fcmToken: device.fcmToken })), { timeout: 5_000 });
         const ack = JSON.parse(sc.decode(ackReply.data));
@@ -546,7 +546,7 @@ const setRingerModeTool = {
     async handler(args, ctx) {
         if (!ctx.nc)
             throw new ToolError("Not connected to server (NATS unavailable)", 503);
-        const device = getCapabilityDevice("dnd");
+        const device = getLinkedDevice();
         if (!device)
             throw new ToolError("No device has Do Not Disturb control enabled", 400);
         const { mode } = args;
@@ -597,9 +597,9 @@ const sendEmailTool = {
     async handler(args, ctx) {
         if (!ctx.nc)
             throw new ToolError("Not connected to server (NATS unavailable)", 503);
-        const device = getCapabilityDevice("send-email");
+        const device = getLinkedDevice();
         if (!device)
-            throw new ToolError("No device has send-email access enabled", 400);
+            throw new ToolError("No linked device configured", 400);
         const { to, subject, body, cc, bcc } = args;
         if (!to)
             throw new ToolError("to is required", 400);

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];