palmier 0.2.4 → 0.2.6

package/src/commands/init.ts

@@ -1,229 +1,244 @@
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
 import * as readline from "readline";
 import { randomUUID, randomBytes } from "crypto";
-import { execSync } from "child_process";
-import { homedir } from "os";
-import { saveConfig } from "../config.js";
+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";
 
-export interface InitOptions {
-  server?: string;
-  lan?: boolean;
-  host?: string;
-  port?: number;
-}
+type AskFn = (q: string) => Promise<string>;
 
-/**
- * Provision this host. Two flows:
- *   - palmier init --lan              → standalone LAN mode, no server needed
- *   - palmier init --server <url>     → register with server, prompts for nats/auto mode
- */
-export async function initCommand(options: InitOptions): Promise<void> {
-  if (options.lan) {
-    await initLan(options);
-  } else if (options.server) {
-    await initWithServer(options);
-  } else {
-    console.error("Either --lan or --server <url> is required.");
-    process.exit(1);
-  }
-}
+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`;
 
 /**
- * Flow A: Standalone LAN mode. No web server needed.
+ * Interactive wizard to provision this host.
  */
-async function initLan(options: InitOptions): Promise<void> {
-  const hostId = randomUUID();
-  const directToken = randomBytes(32).toString("hex");
-  const directPort = options.port ?? 7400;
-  const lanIp = options.host ?? detectLanIp();
-
-  const config: HostConfig = {
-    hostId,
-    mode: "lan",
-    directPort,
-    directToken,
-    projectRoot: process.cwd(),
-  };
-
-  console.log("Detecting installed agents...");
-  config.agents = await detectAgents();
-  saveConfig(config);
-
-  console.log(`Host provisioned (LAN mode). ID: ${hostId}`);
-  console.log("Config saved to ~/.config/palmier/host.json");
-
-  installSystemdService(config);
-
-  // Auto-enter pair mode so user can connect their PWA immediately
-  console.log("");
-  console.log("Starting pairing...");
-  await pairCommand();
-}
+export async function initCommand(): Promise<void> {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const ask: AskFn = (q) => new Promise<string>((resolve) => rl.question(q, resolve));
 
-/**
- * Flow B: Register directly with server. No provisioning token needed.
- */
-async function initWithServer(options: InitOptions): Promise<void> {
-  const serverUrl = options.server!;
+  try {
+    console.log(`\n${bold("=== Palmier Host Setup ===")}\n`);
+    console.log(`By continuing, you agree to the ${cyan("Terms of Service")} (https://www.palmier.me/terms)`);
+    console.log(`and ${cyan("Privacy Policy")} (https://www.palmier.me/privacy).\n`);
+
+    // Detect agents first — abort if none found
+    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(`Install at least one agent CLI, then run ${cyan("palmier init")} again.`);
+      rl.close();
+      process.exit(1);
+    }
 
-  console.log(`Registering host at ${serverUrl}...`);
+    console.log(`  Found: ${green(agents.map((a) => a.label).join(", "))}\n`);
 
-  let registerResponse: {
-    hostId: string;
-    natsUrl: string;
-    natsWsUrl: string;
-    natsToken: string;
-  };
+    let step = 1;
 
-  try {
-    const res = await fetch(`${serverUrl}/api/hosts/register`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({}),
-    });
+    // Step 1: Access mode
+    const accessMode = await promptAccessMode(ask, step++);
 
-    if (!res.ok) {
-      const body = await res.text();
-      console.error(`Failed to register host: ${res.status} ${res.statusText}\n${body}`);
-      process.exit(1);
+    let serverUrl: string | undefined;
+    if (accessMode === "full") {
+      // Step 2: Server URL
+      serverUrl = await promptServerUrl(ask, step++);
     }
 
-    registerResponse = (await res.json()) as typeof registerResponse;
-  } catch (err) {
-    console.error(`Failed to reach server: ${err}`);
-    process.exit(1);
-  }
+    let enableLan = accessMode === "lan";
+    if (accessMode === "full") {
+      // Step N: Optional LAN
+      enableLan = await promptEnableLan(ask, step++);
+    }
 
-  // Prompt for connection mode
-  const mode = await promptMode();
+    // Determine mode
+    const mode: HostConfig["mode"] =
+      accessMode === "lan" ? "lan" : enableLan ? "auto" : "nats";
 
-  // Build config
-  const config: HostConfig = {
-    hostId: registerResponse.hostId,
-    projectRoot: process.cwd(),
-    mode,
-    natsUrl: registerResponse.natsUrl,
-    natsWsUrl: registerResponse.natsWsUrl,
-    natsToken: registerResponse.natsToken,
-  };
+    // Prepare LAN details for summary
+    let lanIp: string | undefined;
+    const directPort = 7400;
+    if (enableLan) {
+      lanIp = detectLanIp();
+    }
 
-  if (mode === "auto") {
-    const directToken = randomBytes(32).toString("hex");
-    const directPort = options.port ?? 7400;
-    const lanIp = options.host ?? 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("");
 
-    config.directPort = directPort;
-    config.directToken = directToken;
+    const confirm = await ask("Proceed? (Y/n): ");
+    if (confirm.trim().toLowerCase() === "n") {
+      console.log("\nSetup cancelled.");
+      rl.close();
+      return;
+    }
 
-    console.log("");
-    console.log("Direct connection info (for LAN clients):");
-    console.log(`  Address: ${lanIp}:${directPort}`);
-    console.log(`  Token:   ${directToken}`);
-  }
+    // 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;
+          }
+        }
+      }
+    }
 
-  console.log("Detecting installed agents...");
-  config.agents = await detectAgents();
-  saveConfig(config);
-  console.log(`Host provisioned (${mode} mode). ID: ${config.hostId}`);
-  console.log("Config saved to ~/.config/palmier/host.json");
+    // Build config
+    const config: HostConfig = {
+      hostId: registerResponse?.hostId ?? randomUUID(),
+      projectRoot: process.cwd(),
+      mode,
+    };
+
+    if (registerResponse) {
+      config.natsUrl = registerResponse.natsUrl;
+      config.natsWsUrl = registerResponse.natsWsUrl;
+      config.natsToken = registerResponse.natsToken;
+    }
 
-  installSystemdService(config);
+    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`));
+      }
+    }
 
-  // Auto-enter pair mode so user can connect their PWA immediately
-  console.log("");
-  console.log("Starting pairing...");
-  await pairCommand();
-}
+    config.agents = agents;
+    saveConfig(config);
 
-/**
- * Prompt user to select connection mode.
- */
-async function promptMode(): Promise<"nats" | "auto"> {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  const question = (q: string) => new Promise<string>((resolve) => rl.question(q, resolve));
+    console.log(`\n${green("Host provisioned")} ${dim(`(${mode} mode)`)} ID: ${cyan(config.hostId)}`);
+    console.log(`Config saved to ${dim("~/.config/palmier/host.json")}`);
 
-  console.log("");
-  console.log("Connection mode:");
-  console.log("  1) auto — Both LAN and NATS (recommended)");
-  console.log("  2) nats — NATS only");
+    getPlatform().installDaemon(config);
+
+    console.log("\nStarting pairing...");
+    rl.close();
+    await pairCommand();
+  } catch (err) {
+    rl.close();
+    throw err;
+  }
+}
+
+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 question("Select [1]: ");
-  rl.close();
+  const answer = await ask("Select [1]: ");
+  const trimmed = answer.trim();
 
-  if (answer.trim() === "2" || answer.trim().toLowerCase() === "nats") {
-    return "nats";
+  if (trimmed === "2") {
+    return "lan";
   }
-  return "auto";
+  return "full";
 }
 
-/**
- * Detect the first non-internal IPv4 address.
- */
-function detectLanIp(): string {
-  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;
-      }
+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");
   }
-  return "127.0.0.1";
 }
 
-/**
- * Install systemd user service for palmier serve.
- */
-function installSystemdService(config: HostConfig): void {
-  const unitDir = path.join(homedir(), ".config", "systemd", "user");
-  fs.mkdirSync(unitDir, { recursive: true });
-
-  const palmierBin = process.argv[1] || "palmier";
-
-  const serviceContent = `[Unit]
-Description=Palmier Host
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-ExecStart=${palmierBin} serve
-WorkingDirectory=${config.projectRoot}
-Restart=on-failure
-RestartSec=5
-Environment=PATH=${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}
-
-[Install]
-WantedBy=default.target
-`;
-
-  const servicePath = path.join(unitDir, "palmier.service");
-  fs.writeFileSync(servicePath, serviceContent, "utf-8");
-  console.log("Systemd service installed at:", servicePath);
-
-  // Enable and start the service
+async function registerHost(
+  serverUrl: string,
+  existingHostId?: string,
+): Promise<{ hostId: string; natsUrl: string; natsWsUrl: string; natsToken: string }> {
   try {
-    execSync("systemctl --user daemon-reload", { stdio: "inherit" });
-    execSync("systemctl --user enable --now palmier.service", { stdio: "inherit" });
-    console.log("Palmier host service enabled and started.");
-  } catch (err) {
-    console.error(`Warning: failed to enable systemd service: ${err}`);
-    console.error("You may need to start it manually: systemctl --user enable --now palmier.service");
-  }
+    const res = await fetch(`${serverUrl}/api/hosts/register`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(existingHostId ? { hostId: existingHostId } : {}),
+    });
 
-  // Enable lingering so service runs without active login session
-  try {
-    execSync(`loginctl enable-linger ${process.env.USER || ""}`, { stdio: "inherit" });
-    console.log("Login lingering enabled.");
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`${res.status} ${res.statusText}\n${body}`);
+    }
+
+    return (await res.json()) as {
+      hostId: string;
+      natsUrl: string;
+      natsWsUrl: string;
+      natsToken: string;
+    };
   } catch (err) {
-    console.error(`Warning: failed to enable linger: ${err}`);
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.includes("fetch failed") || message.includes("ECONNREFUSED") || message.includes("ENOTFOUND") || message.includes("NetworkError")) {
+      throw new Error(`Could not reach ${serverUrl} — check the URL and your network connection.`);
+    }
+    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`);
 
-  console.log("\nHost initialization complete!");
+  const answer = await ask("Enable LAN access? (Y/n): ");
+  return answer.trim().toLowerCase() !== "n";
 }
+
+

package/src/commands/mcpserver.ts

@@ -23,58 +23,47 @@ export async function mcpserverCommand(): Promise<void> {
     { capabilities: { tools: {} } }
   );
 
-  // send-email requires NATS — only register in nats/auto mode
+  // send-push-notification requires NATS — only register in nats/auto mode
   if (nc) {
     server.registerTool(
-      "send-email",
+      "send-push-notification",
       {
-        description: "Send an email via the Palmier platform's SMTP relay",
+        description: "Send a push notification to all paired devices via the Palmier platform",
         inputSchema: {
-          to: z.string().describe("Recipient email address(es), comma-separated"),
-          subject: z.string().describe("Email subject line"),
-          text: z.string().describe("Plain text body"),
-          html: z.string().optional().describe("HTML body"),
-          reply_to: z.string().optional().describe("Reply-To address"),
-          cc: z.string().optional().describe("CC recipients, comma-separated"),
-          bcc: z.string().optional().describe("BCC recipients, comma-separated"),
+          title: z.string().describe("Notification title"),
+          body: z.string().describe("Notification body text"),
         },
       },
       async (args) => {
         const payload = {
           hostId: config.hostId,
-          to: args.to,
-          subject: args.subject,
-          text: args.text,
-          html: args.html,
-          replyTo: args.reply_to,
-          cc: args.cc,
-          bcc: args.bcc,
+          title: args.title,
+          body: args.body,
         };
 
         try {
-          const subject = `host.${config.hostId}.email.send`;
+          const subject = `host.${config.hostId}.push.send`;
           const reply = await nc!.request(subject, sc.encode(JSON.stringify(payload)), {
             timeout: 15_000,
           });
           const result = JSON.parse(sc.decode(reply.data)) as {
             ok?: boolean;
-            messageId?: string;
             error?: string;
           };
 
           if (result.ok) {
             return {
-              content: [{ type: "text" as const, text: `Email sent successfully (messageId: ${result.messageId})` }],
+              content: [{ type: "text" as const, text: "Push notification sent successfully" }],
             };
           } else {
             return {
-              content: [{ type: "text" as const, text: `Failed to send email: ${result.error}` }],
+              content: [{ type: "text" as const, text: `Failed to send push notification: ${result.error}` }],
               isError: true,
             };
           }
         } catch (err) {
           return {
-            content: [{ type: "text" as const, text: `Error sending email: ${err}` }],
+            content: [{ type: "text" as const, text: `Error sending push notification: ${err}` }],
             isError: true,
           };
         }

package/src/commands/plan-generation.md

@@ -1,32 +1,24 @@
-You are a task planning assistant. Given a task description, produce a detailed Markdown execution plan that an agent can follow step by step. **Do not execute any part of the plan yourself.**
-
-Your output must begin with a raw YAML frontmatter block (delimited by `---`), followed by the plan body in Markdown. Do NOT wrap the frontmatter in code fences. The very first line of your output must be `---`.
-
-**Output format:**
-
----
-task_name: <short descriptive name, 3-6 words>
----
-
-<plan body in Markdown>
-
-**Frontmatter fields:**
-
-- `task_name`: A concise label for the task (e.g., "Clean up temp files", "Update system packages", "Backup database daily").
-
-**Plan body sections:**
-
-### 1. Goal
-State what the task accomplishes and the expected end state.
-
-### 2. Plan
-A numbered sequence of concrete, actionable steps. Use sub-steps for complex actions and include conditional branches where behavior may vary (e.g., "If file exists, do A; otherwise, do B"). Each step should be specific enough for the agent to execute without ambiguity.
-
-### 3. Output Format (if applicable)
-If the task produces a report, email, or other formatted output, specify the exact structure, sections, tone, and any templates the agent should follow.
-
-Use Markdown formatting throughout — headings, code blocks, and tables where appropriate.
-
-**Important:** Any relative times or dates in the task description (e.g., "yesterday", "last week") are relative to when the task is executed, not when this plan is generated. The agent must resolve them at execution time.
-
-**Task description:**
+You are a task planning assistant. Given a task description, produce a Markdown execution plan for an agent. **Do not execute any part of the plan yourself.**
+
+Output a raw YAML frontmatter block (delimited by `---`) followed by the plan body. Do NOT wrap frontmatter in code fences. The first line of output must be `---`.
+
+---
+task_name: <short name, 3-6 words>
+---
+
+**Frontmatter:** `task_name` — concise label (e.g., "Clean up temp files", "Backup database daily").
+
+**Plan body:**
+
+### 1. Goal
+What the task accomplishes and the expected end state.
+
+### 2. Plan
+Numbered sequence of concrete, actionable steps. Include conditional branches where behavior may vary. Each step must be unambiguous.
+
+### 3. Output Format (if applicable)
+If the task produces formatted output (report, email, etc.), specify structure, sections, tone, and templates.
+
+Relative times in the task description (e.g., "yesterday") are relative to execution time, not plan generation time.
+
+**Task description:**

package/src/commands/restart.ts

@@ -0,0 +1,9 @@
+import { getPlatform } from "../platform/index.js";
+
+/**
+ * Restart the palmier serve daemon.
+ */
+export async function restartCommand(): Promise<void> {
+  const platform = getPlatform();
+  await platform.restartDaemon();
+}