palmier 0.8.10 → 0.9.2

package/src/network.ts

@@ -1,19 +1,83 @@
 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: 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> {
-  try {
-    const result = await gateway4async() as { int?: string | null };
-    return result.int ?? null;
-  } catch {
-    return 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 {

package/src/rpc-handler.ts

@@ -9,9 +9,9 @@ import { getPlatform } from "./platform/index.js";
 import { spawnCommand } from "./spawn-command.js";
 import crossSpawn from "cross-spawn";
 import { getAgent } from "./agents/agent.js";
-import { validateClient } from "./client-store.js";
+import { validateClient, revokeClient } from "./client-store.js";
 import { publishHostEvent } from "./events.js";
-import { getCapabilityDevice, setCapabilityDevice, clearCapabilityDevice, type DeviceCapability } from "./device-capabilities.js";
+import { getLinkedDevice, setLinkedDevice, clearLinkedDevice, clearLinkedDeviceIfMatches } from "./linked-device.js";
 import { currentVersion, performUpdate } from "./update-checker.js";
 import { parseReportFiles, parseTaskOutcome, stripPalmierMarkers } from "./commands/run.js";
 import { clearTaskQueue } from "./event-queues.js";
@@ -144,15 +144,11 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
 
     switch (request.method) {
       case "host.info": {
-        const capabilities: Record<string, string | null> = {};
-        for (const capability of ["location", "notifications", "sms-read", "sms-send", "contacts", "calendar", "alarm", "battery", "dnd", "send-email"] as const) {
-          capabilities[capability] = getCapabilityDevice(capability)?.clientToken ?? null;
-        }
         return {
           agents: config.agents ?? [],
           version: currentVersion,
           host_platform: process.platform,
-          capability_tokens: capabilities,
+          linked_client_token: getLinkedDevice()?.clientToken ?? null,
           pending_prompts: listPending(),
           lan_url: buildLanUrl(config.httpPort ?? 7256, config.defaultInterface),
         };
@@ -635,31 +631,27 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         return { ok: true };
       }
 
-      case "device.location.enable": {
+      case "device.link": {
         const params = request.params as { fcmToken: string };
         if (!params.fcmToken) return { error: "fcmToken is required" };
         const clientToken = request.clientToken ?? "";
-        setCapabilityDevice("location", clientToken, params.fcmToken);
+        if (!clientToken) return { error: "Unauthorized" };
+        setLinkedDevice(clientToken, params.fcmToken);
         return { ok: true };
       }
 
-      case "device.location.disable": {
-        clearCapabilityDevice("location");
-        return { ok: true };
-      }
-
-      case "device.capability.enable": {
-        const params = request.params as { capability: DeviceCapability; fcmToken: string };
-        if (!params.capability || !params.fcmToken) return { error: "capability and fcmToken are required" };
+      case "device.unlink": {
         const clientToken = request.clientToken ?? "";
-        setCapabilityDevice(params.capability, clientToken, params.fcmToken);
+        const current = getLinkedDevice();
+        if (current?.clientToken === clientToken) clearLinkedDevice();
         return { ok: true };
       }
 
-      case "device.capability.disable": {
-        const params = request.params as { capability: DeviceCapability };
-        if (!params.capability) return { error: "capability is required" };
-        clearCapabilityDevice(params.capability);
+      case "clients.revoke_self": {
+        const clientToken = request.clientToken ?? "";
+        if (!clientToken) return { error: "Unauthorized" };
+        clearLinkedDeviceIfMatches(clientToken);
+        revokeClient(clientToken);
         return { ok: true };
       }
 

package/dist/device-capabilities.d.ts

@@ -1,9 +0,0 @@
-export interface RegisteredDevice {
-    clientToken: string;
-    fcmToken: string;
-}
-export type DeviceCapability = "location" | "notifications" | "sms-read" | "sms-send" | "contacts" | "calendar" | "alarm" | "battery" | "send-email" | "dnd";
-export declare function getCapabilityDevice(capability: DeviceCapability): RegisteredDevice | null;
-export declare function setCapabilityDevice(capability: DeviceCapability, clientToken: string, fcmToken: string): void;
-export declare function clearCapabilityDevice(capability: DeviceCapability): void;
-//# sourceMappingURL=device-capabilities.d.ts.map

package/dist/device-capabilities.js

@@ -1,36 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { CONFIG_DIR } from "./config.js";
-const CAPABILITIES_FILE = path.join(CONFIG_DIR, "device-capabilities.json");
-function readAll() {
-    try {
-        if (!fs.existsSync(CAPABILITIES_FILE))
-            return {};
-        return JSON.parse(fs.readFileSync(CAPABILITIES_FILE, "utf-8"));
-    }
-    catch {
-        return {};
-    }
-}
-function writeAll(map) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
-    fs.writeFileSync(CAPABILITIES_FILE, JSON.stringify(map, null, 2), "utf-8");
-}
-export function getCapabilityDevice(capability) {
-    const map = readAll();
-    const device = map[capability];
-    if (!device?.clientToken || !device?.fcmToken)
-        return null;
-    return device;
-}
-export function setCapabilityDevice(capability, clientToken, fcmToken) {
-    const map = readAll();
-    map[capability] = { clientToken, fcmToken };
-    writeAll(map);
-}
-export function clearCapabilityDevice(capability) {
-    const map = readAll();
-    delete map[capability];
-    writeAll(map);
-}
-//# sourceMappingURL=device-capabilities.js.map