palmier 0.2.6 → 0.2.8

package/src/commands/init.ts

@@ -1,8 +1,6 @@
 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";
 import type { HostConfig } from "../types.js";
@@ -13,7 +11,6 @@ const bold = (s: string) => `\x1b[1m${s}\x1b[0m`;
 const dim = (s: string) => `\x1b[2m${s}\x1b[0m`;
 const green = (s: string) => `\x1b[32m${s}\x1b[0m`;
 const cyan = (s: string) => `\x1b[36m${s}\x1b[0m`;
-const yellow = (s: string) => `\x1b[33m${s}\x1b[0m`;
 const red = (s: string) => `\x1b[31m${s}\x1b[0m`;
 
 /**
@@ -33,11 +30,8 @@ export async function initCommand(): Promise<void> {
     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);
@@ -45,118 +39,44 @@ export async function initCommand(): Promise<void> {
 
     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: string | undefined;
-    if (accessMode === "full") {
-      // Step 2: Server URL
-      serverUrl = await promptServerUrl(ask, step++);
-    }
-
-    let enableLan = accessMode === "lan";
-    if (accessMode === "full") {
-      // Step N: Optional LAN
-      enableLan = await promptEnableLan(ask, step++);
-    }
-
-    // Determine mode
-    const mode: HostConfig["mode"] =
-      accessMode === "lan" ? "lan" : enableLan ? "auto" : "nats";
-
-    // Prepare LAN details for summary
-    let lanIp: string | undefined;
-    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)
-    let registerResponse:
-      | { hostId: string; natsUrl: string; natsWsUrl: string; natsToken: string }
-      | undefined;
-
-    if (accessMode === "full" && serverUrl) {
-      let existingHostId: string | undefined;
-      try { existingHostId = loadConfig().hostId; } 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;
-          }
+    // Register with server
+    let existingHostId: string | undefined;
+    try { existingHostId = loadConfig().hostId; } catch { /* first init */ }
+
+    const serverUrl = "https://app.palmier.me";
+    let registerResponse: { hostId: string; natsUrl: string; natsWsUrl: string; natsToken: string };
+
+    while (true) {
+      console.log(`\nRegistering host...`);
+      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;
         }
       }
     }
 
     // Build config
     const config: HostConfig = {
-      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);
@@ -170,36 +90,6 @@ export async function initCommand(): Promise<void> {
   }
 }
 
-async function promptAccessMode(ask: AskFn, step: number): Promise<"full" | "lan"> {
-  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: AskFn, step: number): Promise<string> {
-  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: string,
@@ -231,14 +121,3 @@ async function registerHost(
     throw new Error(`Failed to register host: ${message}`);
   }
 }
-
-async function promptEnableLan(ask: AskFn, step: number): Promise<boolean> {
-  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";
-}
-
-

package/src/commands/lan.ts

@@ -0,0 +1,58 @@
+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: string) => `\x1b[1m${s}\x1b[0m`;
+const cyan = (s: string) => `\x1b[36m${s}\x1b[0m`;
+const dim = (s: string) => `\x1b[2m${s}\x1b[0m`;
+
+const CODE_CHARS = "ABCDEFGHJKMNPQRSTUVWXYZ23456789";
+const CODE_LENGTH = 6;
+
+function generateCode(): string {
+  const bytes = new Uint8Array(CODE_LENGTH);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => CODE_CHARS[b % CODE_CHARS.length]).join("");
+}
+
+function writeLockfile(port: number): void {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(LAN_LOCKFILE, JSON.stringify({ port, pid: process.pid }), "utf-8");
+}
+
+function removeLockfile(): void {
+  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: { port: number }): Promise<void> {
+  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`);
+  });
+}

package/src/commands/mcpserver.ts

@@ -4,17 +4,9 @@ import { z } from "zod";
 import { StringCodec } from "nats";
 import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
-import type { NatsConnection } from "nats";
-
 export async function mcpserverCommand(): Promise<void> {
   const config = loadConfig();
-  const mode = config.mode ?? "nats";
-  const useNats = mode === "nats" || mode === "auto";
-
-  let nc: NatsConnection | undefined;
-  if (useNats) {
-    nc = await connectNats(config);
-  }
+  const nc = await connectNats(config);
 
   const sc = StringCodec();
 
@@ -23,7 +15,7 @@ export async function mcpserverCommand(): Promise<void> {
     { 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",

package/src/commands/pair.ts

@@ -1,14 +1,16 @@
+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";
 import type { HostConfig } from "../types.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(): string {
   const bytes = new Uint8Array(CODE_LENGTH);
@@ -18,17 +20,14 @@ function generateCode(): string {
 
 function buildPairResponse(config: HostConfig, label?: string) {
   const session = addSession(label);
-  const response: Record<string, unknown> = {
+  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: number, code: string): Promise<boolean> {
   const body = JSON.stringify({ code, expiryMs: EXPIRY_MS });
@@ -41,16 +40,14 @@ function lanPairRegister(port: number, code: string): Promise<boolean> {
         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: Buffer[] = [];
         res.on("data", (chunk: Buffer) => chunks.push(chunk));
         res.on("end", () => {
           try {
-            const result = JSON.parse(Buffer.concat(chunks).toString("utf-8")) as {
-              paired: boolean;
-            };
+            const result = JSON.parse(Buffer.concat(chunks).toString("utf-8")) as { paired: boolean };
             resolve(result.paired);
           } catch {
             resolve(false);
@@ -59,29 +56,29 @@ function lanPairRegister(port: number, code: string): Promise<boolean> {
       },
     );
 
-    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(): number | null {
+  try {
+    const raw = fs.readFileSync(LAN_LOCKFILE, "utf-8");
+    return (JSON.parse(raw) as { port: number }).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(): Promise<void> {
   const config = loadConfig();
   const code = generateCode();
-  const mode = config.mode ?? "nats";
 
   let paired = false;
 
@@ -98,53 +95,43 @@ export async function pairCommand(): Promise<void> {
   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();
-    });
+  // NATS pairing (always active)
+  const nc = await connectNats(config);
+  const sc = StringCodec();
+  const subject = `pair.${code}`;
+  const sub = nc.subscribe(subject, { max: 1 });
 
-    (async () => {
-      for await (const msg of sub) {
-        if (paired) break;
-        let label: string | undefined;
-        try {
-          if (msg.data && msg.data.length > 0) {
-            const body = JSON.parse(sc.decode(msg.data)) as { label?: string };
-            label = body.label;
-          }
-        } catch { /* empty body is fine */ }
+  cleanups.push(() => {
+    sub.unsubscribe();
+    nc.close();
+  });
 
-        const response = buildPairResponse(config, label);
-        if (msg.reply) {
-          msg.respond(sc.encode(JSON.stringify(response)));
+  (async () => {
+    for await (const msg of sub) {
+      if (paired) break;
+      let label: string | undefined;
+      try {
+        if (msg.data && msg.data.length > 0) {
+          const body = JSON.parse(sc.decode(msg.data)) as { label?: string };
+          label = body.label;
         }
-        onPaired();
+      } catch { /* empty body is fine */ }
+
+      const response = buildPairResponse(config, label);
+      if (msg.reply) {
+        msg.respond(sc.encode(JSON.stringify(response)));
       }
-    })();
-  }
+      onPaired();
+    }
+  })();
 
-  // LAN pairing — long-poll the running serve process
-  if (mode === "lan" || mode === "auto") {
-    const port = config.directPort ?? 7400;
+  // 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();
     })();
   }