palmier 0.2.6 → 0.2.7

package/README.md

@@ -8,17 +8,16 @@ A Node.js CLI that runs on your machine as a persistent daemon. It manages tasks
 
 ## Connection Modes
 
-The host supports three connection modes:
+The host supports two independent connection modes, enabled during `palmier init`. Both can be active at the same time.
 
-| Mode | Transport | Setup | Features |
-|------|-----------|-------|----------|
-| **`nats`** | NATS only | `palmier init` → Full access, skip LAN | All features |
-| **`auto`** | Both NATS + HTTP | `palmier init` → Full access + LAN | All features. PWA auto-detects best route. |
-| **`lan`** | HTTP only | `palmier init` → LAN only | No push notifications. No server needed. |
+| Mode | Transport | PWA URL | Features |
+|------|-----------|---------|----------|
+| **Server** | NATS (cloud relay) | `https://app.palmier.me` | Push notifications, remote access |
+| **LAN** | HTTP (direct, on-demand) | `http://<host-ip>:7400` | Low-latency, no external server needed |
 
-In **auto** mode, the PWA connects directly to the host via HTTP when on the same LAN (lower latency), and falls back to NATS when the host is unreachable. Push notifications always flow through NATS/server, so no features are lost.
+**Server mode** relays communication through the Palmier server via NATS. All features including push notifications are available. The PWA is served over HTTPS.
 
-In **lan** mode, the host runs a standalone HTTP server. Multiple PWA clients can connect using session tokens. No Palmier web server or NATS broker is needed.
+**LAN mode** is started on-demand via `palmier lan`. It runs a local HTTP server that reverse-proxies PWA assets from `app.palmier.me` and serves API endpoints locally. The browser accesses everything at `http://<host-ip>:<port>` (same-origin). Push notifications are not available in LAN mode.
 
 ## Prerequisites
 
@@ -36,8 +35,9 @@ npm install -g palmier
 
 | Command | Description |
 |---|---|
-| `palmier init` | Interactive setup wizard (full access or LAN only) |
-| `palmier pair` | Generate an OTP code to pair a new device |
+| `palmier init` | Interactive setup wizard |
+| `palmier pair` | Generate an OTP code to pair a new device (server mode) |
+| `palmier lan` | Start an on-demand LAN server with built-in pairing |
 | `palmier sessions list` | List active session tokens |
 | `palmier sessions revoke <token>` | Revoke a specific session token |
 | `palmier sessions revoke-all` | Revoke all session tokens |
@@ -54,16 +54,14 @@ npm install -g palmier
 
 1. Install the host: `npm install -g palmier`
 2. Run `palmier init` in your project directory.
-3. The wizard walks you through:
-   - **Full access** or **LAN only** mode
-   - Server URL (for full access, used for registration only — not stored in config)
-   - Optional LAN access (for full access — auto-detects best route when enabled)
-4. The host saves config, installs a background daemon (systemd on Linux, Registry Run key on Windows), and generates a pairing code.
-5. Enter the pairing code in the Palmier PWA to connect your device.
+3. The wizard detects installed agents, registers with the Palmier server, installs a background daemon, and generates a pairing code.
+4. Enter the pairing code in the Palmier PWA to connect your device.
 
 ### Pairing additional devices
 
-Run `palmier pair` on the host to generate a new OTP code. Each paired device gets its own session token.
+**Server mode:** Run `palmier pair` on the host to generate a new OTP code. Enter it in the PWA at `https://app.palmier.me`.
+
+**LAN mode:** Run `palmier lan` — it displays both the URL and a pairing code. Open the URL on your device and enter the code.
 
 ### Managing sessions
 
@@ -119,15 +117,15 @@ palmier restart
 ## How It Works
 
 - The host runs as a **background daemon** (systemd user service on Linux, Registry Run key on Windows), staying alive via `palmier serve`.
-- **Paired devices** communicate with the host via NATS (cloud-routed) and/or direct HTTP (LAN), depending on the connection mode. Each paired device gets a session token that authenticates all requests.
-- **Tasks** are stored locally as Markdown files in a `tasks/` directory. Each task has a name, prompt, execution plan, and optional triggers (cron schedules or one-time dates).
+- **Paired devices** communicate with the host via NATS (server mode) and/or direct HTTP (LAN mode). Each paired device gets a session token that authenticates all requests.
+- **Tasks** are stored locally as Markdown files in a `tasks/` directory. Each task has a name, prompt, execution plan, and optional schedules (cron schedules or one-time dates).
 - **Plan generation** is automatic — when you create or update a task, the host invokes your chosen agent CLI to generate an execution plan and name.
-- **Triggers** are backed by systemd timers (Linux) or Task Scheduler (Windows). You can enable/disable them without deleting the task, and any task can still be run manually at any time.
+- **Schedules** are backed by systemd timers (Linux) or Task Scheduler (Windows). You can enable/disable them without deleting the task, and any task can still be run manually at any time.
 - **Task execution** uses the system scheduler on both platforms — `systemctl --user start` on Linux, `schtasks /run` on Windows. The daemon polls every 30 seconds to detect crashed tasks (processes that exited without updating status) and marks them as failed, broadcasting the failure to connected clients.
 - **Command-triggered tasks** — optionally specify a shell command (e.g., `tail -f /var/log/app.log`). Palmier runs the command continuously and invokes the agent for each line of stdout, passing it alongside your prompt. Useful for log monitoring, event-driven automation, and reactive workflows.
-- **Task confirmation** — tasks can optionally require your approval before running. You'll get a push notification (NATS mode) or a prompt in the PWA to confirm or abort.
+- **Task confirmation** — tasks can optionally require your approval before running. You'll get a push notification (server mode) or a prompt in the PWA to confirm or abort.
 - **Run history** — each run produces a timestamped result file. You can view results and reports from the PWA.
-- **Real-time updates** — task status changes (started, finished, failed) are pushed to connected PWA clients via NATS pub/sub or SSE. A shared events module handles broadcasting across both transports.
+- **Real-time updates** — task status changes (started, finished, failed) are pushed to connected PWA clients via NATS pub/sub (server mode) and/or SSE (LAN mode).
 - **MCP server** (`palmier mcpserver`) exposes platform tools (e.g., `send-push-notification`) to AI agents like Claude Code over stdio.
 
 ## Project Structure
@@ -148,7 +146,7 @@ src/
     gemini.ts         # Gemini CLI agent implementation
     codex.ts          # Codex CLI agent implementation
     openclaw.ts       # OpenClaw agent implementation
-  events.ts           # Shared event broadcasting (NATS pub/sub and HTTP SSE)
+  events.ts           # Event broadcasting (NATS pub/sub or HTTP SSE)
   commands/
     init.ts           # Interactive setup wizard (auto-pair)
     pair.ts           # OTP code generation and pairing handler
@@ -166,7 +164,7 @@ src/
     windows.ts        # Windows: Registry Run key, Task Scheduler, schtasks-based task control
   transports/
     nats-transport.ts # NATS subscription loop (host.<hostId>.rpc.>)
-    http-transport.ts # HTTP server with RPC, SSE, and internal event endpoints
+    http-transport.ts # HTTP server with RPC, SSE, PWA reverse proxy, and internal event endpoints
 ```
 
 ## MCP Server
@@ -188,7 +186,7 @@ Add to your Claude Code MCP settings:
 }
 ```
 
-Requires a provisioned host (`palmier init`). In NATS/auto mode, uses NATS relay. Not available in LAN-only mode.
+Requires a provisioned host (`palmier init`) with server mode enabled.
 
 ### Available Tools
 
@@ -273,7 +271,7 @@ Tasks can be configured to run on schedules (cron) or in response to events with
 
 Task prompts and execution data may be transmitted to third-party AI service providers (Anthropic, Google, OpenAI, etc.) according to their respective terms and privacy policies. Palmier does not control how these services process your data.
 
-When using NATS or auto mode, communication between your device and the host is relayed through the Palmier server. See the [Privacy Policy](https://www.palmier.me/privacy) for details on what data is collected.
+When using server mode, communication between your device and the host is relayed through the Palmier server. See the [Privacy Policy](https://www.palmier.me/privacy) for details on what data is collected.
 
 ### Limitation of Liability
 

package/dist/commands/info.js

@@ -1,35 +1,13 @@
-import * as os from "os";
 import { loadConfig } from "../config.js";
 import { loadSessions } from "../session-store.js";
-/**
- * Detect the first non-internal IPv4 address.
- */
-function detectLanIp() {
-    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;
-            }
-        }
-    }
-    return "127.0.0.1";
-}
 /**
  * Print host connection info for setting up clients.
  */
 export async function infoCommand() {
     const config = loadConfig();
-    const mode = config.mode ?? "nats";
     const sessions = loadSessions();
     console.log(`Host ID:      ${config.hostId}`);
-    console.log(`Mode:         ${mode}`);
     console.log(`Project root: ${config.projectRoot}`);
-    if (mode === "lan" || mode === "auto") {
-        const lanIp = detectLanIp();
-        const port = config.directPort ?? 7400;
-        console.log(`LAN address:  ${lanIp}:${port}`);
-    }
     // Detected agents
     if (config.agents && config.agents.length > 0) {
         console.log(`Agents:       ${config.agents.map((a) => a.label).join(", ")}`);

package/dist/commands/init.js

@@ -1,15 +1,12 @@
 import * as readline from "readline";
-import { randomUUID, randomBytes } from "crypto";
 import { loadConfig, saveConfig } from "../config.js";
 import { detectAgents } from "../agents/agent.js";
-import { detectLanIp } from "../transports/http-transport.js";
 import { getPlatform } from "../platform/index.js";
 import { pairCommand } from "./pair.js";
 const bold = (s) => `\x1b[1m${s}\x1b[0m`;
 const dim = (s) => `\x1b[2m${s}\x1b[0m`;
 const green = (s) => `\x1b[32m${s}\x1b[0m`;
 const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
-const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
 const red = (s) => `\x1b[31m${s}\x1b[0m`;
 /**
  * Interactive wizard to provision this host.
@@ -25,112 +22,50 @@ export async function initCommand() {
         console.log("Detecting installed agents...");
         const agents = await detectAgents();
         if (agents.length === 0) {
-            console.log(`\n${red("No agent CLIs detected.")} Palmier requires at least one of the following:\n`);
-            console.log(`  - ${bold("Claude Code")}    See https://code.claude.com`);
-            console.log(`  - ${bold("Gemini CLI")}     npm install -g @google/gemini-cli`);
-            console.log(`  - ${bold("Codex CLI")}      npm install -g @openai/codex`);
-            console.log(`  - ${bold("OpenClaw")}       See https://github.com/openclaw/openclaw\n`);
+            console.log(`\n${red("No agent CLIs detected.")} Palmier requires at least one supported agent CLI.\n`);
+            console.log(`See supported agents: https://www.palmier.me/agents\n`);
             console.log(`Install at least one agent CLI, then run ${cyan("palmier init")} again.`);
             rl.close();
             process.exit(1);
         }
         console.log(`  Found: ${green(agents.map((a) => a.label).join(", "))}\n`);
-        let step = 1;
-        // Step 1: Access mode
-        const accessMode = await promptAccessMode(ask, step++);
-        let serverUrl;
-        if (accessMode === "full") {
-            // Step 2: Server URL
-            serverUrl = await promptServerUrl(ask, step++);
+        // Register with server
+        let existingHostId;
+        try {
+            existingHostId = loadConfig().hostId;
         }
-        let enableLan = accessMode === "lan";
-        if (accessMode === "full") {
-            // Step N: Optional LAN
-            enableLan = await promptEnableLan(ask, step++);
-        }
-        // Determine mode
-        const mode = accessMode === "lan" ? "lan" : enableLan ? "auto" : "nats";
-        // Prepare LAN details for summary
-        let lanIp;
-        const directPort = 7400;
-        if (enableLan) {
-            lanIp = detectLanIp();
-        }
-        // Summary before committing
-        console.log(`\n${bold("--- Setup Summary ---")}\n`);
-        console.log(`  Mode:    ${cyan(mode)}${dim(mode === "auto" ? " (NATS + LAN)" : mode === "nats" ? " (NATS only)" : " (LAN only)")}`);
-        if (serverUrl) {
-            console.log(`  Server:  ${cyan(serverUrl)}`);
-        }
-        if (enableLan && lanIp) {
-            console.log(`  LAN:     ${cyan(`${lanIp}:${directPort}`)}`);
-        }
-        console.log(`  Agents:  ${green(agents.map((a) => a.label).join(", "))}`);
-        console.log("");
-        const confirm = await ask("Proceed? (Y/n): ");
-        if (confirm.trim().toLowerCase() === "n") {
-            console.log("\nSetup cancelled.");
-            rl.close();
-            return;
-        }
-        // Register with server (after confirmation)
+        catch { /* first init */ }
+        const serverUrl = "https://app.palmier.me";
         let registerResponse;
-        if (accessMode === "full" && serverUrl) {
-            let existingHostId;
+        while (true) {
+            console.log(`\nRegistering host...`);
             try {
-                existingHostId = loadConfig().hostId;
+                registerResponse = await registerHost(serverUrl, existingHostId);
+                console.log(green("Host registered successfully."));
+                break;
             }
-            catch { /* first init */ }
-            while (true) {
-                console.log(`\nRegistering host with ${cyan(serverUrl)}...`);
-                try {
-                    registerResponse = await registerHost(serverUrl, existingHostId);
-                    console.log(green("Host registered successfully."));
-                    break;
-                }
-                catch (err) {
-                    console.error(`\n  ${red(err instanceof Error ? err.message : String(err))}`);
-                    const retry = await ask("\nRetry? (Y/n): ");
-                    if (retry.trim().toLowerCase() === "n") {
-                        console.log("\nSetup cancelled.");
-                        rl.close();
-                        return;
-                    }
+            catch (err) {
+                console.error(`\n  ${red(err instanceof Error ? err.message : String(err))}`);
+                const retry = await ask("\nRetry? (Y/n): ");
+                if (retry.trim().toLowerCase() === "n") {
+                    console.log("\nSetup cancelled.");
+                    rl.close();
+                    return;
                 }
             }
         }
         // Build config
         const config = {
-            hostId: registerResponse?.hostId ?? randomUUID(),
+            hostId: registerResponse.hostId,
             projectRoot: process.cwd(),
-            mode,
+            nats: true,
+            natsUrl: registerResponse.natsUrl,
+            natsWsUrl: registerResponse.natsWsUrl,
+            natsToken: registerResponse.natsToken,
+            agents,
         };
-        if (registerResponse) {
-            config.natsUrl = registerResponse.natsUrl;
-            config.natsWsUrl = registerResponse.natsWsUrl;
-            config.natsToken = registerResponse.natsToken;
-        }
-        if (enableLan) {
-            const directToken = randomBytes(32).toString("hex");
-            config.directPort = directPort;
-            config.directToken = directToken;
-            console.log(`\n  LAN IP:  ${cyan(lanIp)}`);
-            console.log(`  Port:    ${cyan(String(directPort))}`);
-            if (process.platform === "win32") {
-                console.log(`\n  ${yellow("Firewall:")} You may need to allow incoming connections on this port:`);
-                console.log(dim(`    netsh advfirewall firewall add rule name="Palmier" dir=in action=allow protocol=TCP localport=${directPort}`));
-            }
-            else if (process.platform === "darwin") {
-                console.log(`\n  ${yellow("Firewall:")} macOS will prompt you to allow incoming connections automatically.`);
-            }
-            else {
-                console.log(`\n  ${yellow("Firewall:")} You may need to allow incoming connections on this port:`);
-                console.log(dim(`    sudo ufw allow ${directPort}/tcp`));
-            }
-        }
-        config.agents = agents;
         saveConfig(config);
-        console.log(`\n${green("Host provisioned")} ${dim(`(${mode} mode)`)} ID: ${cyan(config.hostId)}`);
+        console.log(`\n${green("Host provisioned")} ID: ${cyan(config.hostId)}`);
         console.log(`Config saved to ${dim("~/.config/palmier/host.json")}`);
         getPlatform().installDaemon(config);
         console.log("\nStarting pairing...");
@@ -142,30 +77,6 @@ export async function initCommand() {
         throw err;
     }
 }
-async function promptAccessMode(ask, step) {
-    console.log(`${bold(`Step ${step}:`)} Choose access mode\n`);
-    console.log(`  ${bold("1)")} Full access  ${dim("— built-in email and push notification support")}`);
-    console.log(`  ${bold("2)")} LAN only     ${dim("— no data relayed by palmier server, requires same network")}`);
-    console.log("");
-    const answer = await ask("Select [1]: ");
-    const trimmed = answer.trim();
-    if (trimmed === "2") {
-        return "lan";
-    }
-    return "full";
-}
-async function promptServerUrl(ask, step) {
-    const defaultUrl = "https://www.palmier.me";
-    console.log(`\n${bold(`Step ${step}:`)} Enter your Palmier server URL\n`);
-    while (true) {
-        const answer = await ask(`Server URL [${defaultUrl}]: `);
-        const trimmed = (answer.trim() || defaultUrl).replace(/\/+$/, "");
-        if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
-            return trimmed;
-        }
-        console.log("  URL must start with http:// or https://. Please try again.\n");
-    }
-}
 async function registerHost(serverUrl, existingHostId) {
     try {
         const res = await fetch(`${serverUrl}/api/hosts/register`, {
@@ -187,11 +98,4 @@ async function registerHost(serverUrl, existingHostId) {
         throw new Error(`Failed to register host: ${message}`);
     }
 }
-async function promptEnableLan(ask, step) {
-    console.log(`\n${bold(`Step ${step}:`)} Enable LAN access?\n`);
-    console.log(`  ${dim("When enabled, the app will automatically use a direct LAN connection")}`);
-    console.log(`  ${dim("when on the same network, and fall back to the server otherwise.")}\n`);
-    const answer = await ask("Enable LAN access? (Y/n): ");
-    return answer.trim().toLowerCase() !== "n";
-}
 //# sourceMappingURL=init.js.map

package/dist/commands/lan.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Start an on-demand LAN server for direct HTTP connections.
+ * Generates a pairing code and displays it — no separate `palmier pair` needed.
+ */
+export declare function lanCommand(opts: {
+    port: number;
+}): Promise<void>;
+//# sourceMappingURL=lan.d.ts.map

package/dist/commands/lan.js

@@ -0,0 +1,51 @@
+import * as fs from "fs";
+import * as path from "path";
+import { loadConfig, CONFIG_DIR } from "../config.js";
+import { createRpcHandler } from "../rpc-handler.js";
+import { startHttpTransport, detectLanIp } from "../transports/http-transport.js";
+const LAN_LOCKFILE = path.join(CONFIG_DIR, "lan.json");
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+const CODE_CHARS = "ABCDEFGHJKMNPQRSTUVWXYZ23456789";
+const CODE_LENGTH = 6;
+function generateCode() {
+    const bytes = new Uint8Array(CODE_LENGTH);
+    crypto.getRandomValues(bytes);
+    return Array.from(bytes, (b) => CODE_CHARS[b % CODE_CHARS.length]).join("");
+}
+function writeLockfile(port) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(LAN_LOCKFILE, JSON.stringify({ port, pid: process.pid }), "utf-8");
+}
+function removeLockfile() {
+    try {
+        fs.unlinkSync(LAN_LOCKFILE);
+    }
+    catch { /* ignore */ }
+}
+/**
+ * Start an on-demand LAN server for direct HTTP connections.
+ * Generates a pairing code and displays it — no separate `palmier pair` needed.
+ */
+export async function lanCommand(opts) {
+    const config = loadConfig();
+    const port = opts.port;
+    const ip = detectLanIp();
+    const code = generateCode();
+    const handleRpc = createRpcHandler(config);
+    // Write lockfile so other palmier processes can discover us
+    writeLockfile(port);
+    // Clean up on exit
+    process.on("SIGINT", () => { removeLockfile(); process.exit(0); });
+    process.on("SIGTERM", () => { removeLockfile(); process.exit(0); });
+    process.on("exit", removeLockfile);
+    // Start the HTTP transport with the pre-generated pairing code
+    await startHttpTransport(config, handleRpc, port, code, () => {
+        console.log(`\n${bold("Palmier LAN Server")}\n`);
+        console.log(`  ${cyan("Open the app at:")} ${bold(`http://${ip}:${port}`)}\n`);
+        console.log(`  ${cyan("Pairing code:")}    ${bold(code)}\n`);
+        console.log(`  ${dim("Press Ctrl+C to stop.")}\n`);
+    });
+}
+//# sourceMappingURL=lan.js.map

package/dist/commands/mcpserver.js

@@ -6,15 +6,10 @@ import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
 export async function mcpserverCommand() {
     const config = loadConfig();
-    const mode = config.mode ?? "nats";
-    const useNats = mode === "nats" || mode === "auto";
-    let nc;
-    if (useNats) {
-        nc = await connectNats(config);
-    }
+    const nc = await connectNats(config);
     const sc = StringCodec();
     const server = new McpServer({ name: "palmier", version: "1.0.0" }, { capabilities: { tools: {} } });
-    // send-push-notification requires NATS — only register in nats/auto mode
+    // send-push-notification requires NATS — only register when server mode is enabled
     if (nc) {
         server.registerTool("send-push-notification", {
             description: "Send a push notification to all paired devices via the Palmier platform",

package/dist/commands/pair.d.ts

@@ -1,6 +1,6 @@
 /**
  * Generate an OTP code and wait for a PWA client to pair.
- * Listens on NATS (nats/auto modes) and/or HTTP (lan/auto modes).
+ * Listens on NATS always, and also on the LAN server if `palmier lan` is running.
  */
 export declare function pairCommand(): Promise<void>;
 //# sourceMappingURL=pair.d.ts.map

package/dist/commands/pair.js

@@ -1,12 +1,14 @@
+import * as fs from "fs";
+import * as path from "path";
 import * as http from "node:http";
 import { StringCodec } from "nats";
-import { loadConfig } from "../config.js";
+import { loadConfig, CONFIG_DIR } from "../config.js";
 import { connectNats } from "../nats-client.js";
-import { detectLanIp } from "../transports/http-transport.js";
 import { addSession } from "../session-store.js";
 const CODE_CHARS = "ABCDEFGHJKMNPQRSTUVWXYZ23456789"; // no O/0/I/1/L
 const CODE_LENGTH = 6;
 const EXPIRY_MS = 5 * 60 * 1000; // 5 minutes
+const LAN_LOCKFILE = path.join(CONFIG_DIR, "lan.json");
 function generateCode() {
     const bytes = new Uint8Array(CODE_LENGTH);
     crypto.getRandomValues(bytes);
@@ -14,15 +16,13 @@ function generateCode() {
 }
 function buildPairResponse(config, label) {
     const session = addSession(label);
-    const response = {
+    return {
         hostId: config.hostId,
         sessionToken: session.token,
     };
-    return response;
 }
 /**
- * POST to the running serve process and long-poll until paired or expired.
- * Returns true if paired, false if expired/failed.
+ * POST to the running LAN server and long-poll until paired or expired.
  */
 function lanPairRegister(port, code) {
     const body = JSON.stringify({ code, expiryMs: EXPIRY_MS });
@@ -33,7 +33,7 @@ function lanPairRegister(port, code) {
             path: "/internal/pair-register",
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            timeout: EXPIRY_MS + 5000, // slightly longer than expiry
+            timeout: EXPIRY_MS + 5000,
         }, (res) => {
             const chunks = [];
             res.on("data", (chunk) => chunks.push(chunk));
@@ -47,26 +47,30 @@ function lanPairRegister(port, code) {
                 }
             });
         });
-        req.on("error", (err) => {
-            console.error(`Failed to reach palmier serve on port ${port}: ${err.message}`);
-            console.error("Make sure `palmier serve` is running first.");
-            resolve(false);
-        });
-        req.on("timeout", () => {
-            req.destroy();
-            resolve(false);
-        });
+        req.on("error", () => resolve(false));
+        req.on("timeout", () => { req.destroy(); resolve(false); });
         req.end(body);
     });
 }
+/**
+ * Read the LAN lockfile to check if `palmier lan` is running.
+ */
+function getLanPort() {
+    try {
+        const raw = fs.readFileSync(LAN_LOCKFILE, "utf-8");
+        return JSON.parse(raw).port;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Generate an OTP code and wait for a PWA client to pair.
- * Listens on NATS (nats/auto modes) and/or HTTP (lan/auto modes).
+ * Listens on NATS always, and also on the LAN server if `palmier lan` is running.
  */
 export async function pairCommand() {
     const config = loadConfig();
     const code = generateCode();
-    const mode = config.mode ?? "nats";
     let paired = false;
     function onPaired() {
         paired = true;
@@ -79,48 +83,40 @@ export async function pairCommand() {
     console.log("");
     console.log(`  ${code}`);
     console.log("");
-    if (mode === "lan" || mode === "auto") {
-        const ip = detectLanIp();
-        const port = config.directPort ?? 7400;
-        console.log(`  LAN Address: ${ip}:${port}`);
-        console.log("");
-    }
     console.log("Code expires in 5 minutes.");
-    // NATS pairing (nats or auto mode)
-    if (mode === "nats" || mode === "auto") {
-        const nc = await connectNats(config);
-        const sc = StringCodec();
-        const subject = `pair.${code}`;
-        const sub = nc.subscribe(subject, { max: 1 });
-        cleanups.push(() => {
-            sub.unsubscribe();
-            nc.close();
-        });
-        (async () => {
-            for await (const msg of sub) {
-                if (paired)
-                    break;
-                let label;
-                try {
-                    if (msg.data && msg.data.length > 0) {
-                        const body = JSON.parse(sc.decode(msg.data));
-                        label = body.label;
-                    }
-                }
-                catch { /* empty body is fine */ }
-                const response = buildPairResponse(config, label);
-                if (msg.reply) {
-                    msg.respond(sc.encode(JSON.stringify(response)));
+    // NATS pairing (always active)
+    const nc = await connectNats(config);
+    const sc = StringCodec();
+    const subject = `pair.${code}`;
+    const sub = nc.subscribe(subject, { max: 1 });
+    cleanups.push(() => {
+        sub.unsubscribe();
+        nc.close();
+    });
+    (async () => {
+        for await (const msg of sub) {
+            if (paired)
+                break;
+            let label;
+            try {
+                if (msg.data && msg.data.length > 0) {
+                    const body = JSON.parse(sc.decode(msg.data));
+                    label = body.label;
                 }
-                onPaired();
             }
-        })();
-    }
-    // LAN pairing — long-poll the running serve process
-    if (mode === "lan" || mode === "auto") {
-        const port = config.directPort ?? 7400;
+            catch { /* empty body is fine */ }
+            const response = buildPairResponse(config, label);
+            if (msg.reply) {
+                msg.respond(sc.encode(JSON.stringify(response)));
+            }
+            onPaired();
+        }
+    })();
+    // LAN pairing — if `palmier lan` is running, also register with it
+    const lanPort = getLanPort();
+    if (lanPort) {
         (async () => {
-            const result = await lanPairRegister(port, code);
+            const result = await lanPairRegister(lanPort, code);
             if (result)
                 onPaired();
         })();