palmier 0.2.0 → 0.2.2

package/dist/commands/init.js

@@ -1,92 +1,182 @@
 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 { detectAgents } from "../agents/agent.js";
+import { pairCommand } from "./pair.js";
 /**
- * Provision this agent by exchanging a base64 provisioning token for permanent credentials.
+ * 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) {
-    // 1. Decode base64 provisioning token
-    let decoded;
-    try {
-        const jsonStr = Buffer.from(options.token, "base64").toString("utf-8");
-        decoded = JSON.parse(jsonStr);
+    if (options.lan) {
+        await initLan(options);
     }
-    catch {
-        console.error("Failed to decode provisioning token. Ensure it is a valid base64-encoded JSON string.");
-        process.exit(1);
+    else if (options.server) {
+        await initWithServer(options);
     }
-    if (!decoded.server || !decoded.token) {
-        console.error("Invalid provisioning token: missing 'server' or 'token' field.");
+    else {
+        console.error("Either --lan or --server <url> is required.");
         process.exit(1);
     }
-    console.log(`Claiming agent at ${decoded.server}...`);
-    // 2. POST to server to claim agent
-    let claimResponse;
+}
+/**
+ * Flow A: Standalone LAN mode. No web server needed.
+ */
+async function initLan(options) {
+    const hostId = randomUUID();
+    const directToken = randomBytes(32).toString("hex");
+    const directPort = options.port ?? 7400;
+    const lanIp = options.host ?? detectLanIp();
+    const config = {
+        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();
+}
+/**
+ * Flow B: Register directly with server. No provisioning token needed.
+ */
+async function initWithServer(options) {
+    const serverUrl = options.server;
+    console.log(`Registering host at ${serverUrl}...`);
+    let registerResponse;
     try {
-        const res = await fetch(`${decoded.server}/api/agents/claim`, {
+        const res = await fetch(`${serverUrl}/api/hosts/register`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ provisioning_token: options.token }),
+            body: JSON.stringify({}),
         });
         if (!res.ok) {
             const body = await res.text();
-            console.error(`Failed to claim agent: ${res.status} ${res.statusText}\n${body}`);
+            console.error(`Failed to register host: ${res.status} ${res.statusText}\n${body}`);
             process.exit(1);
         }
-        claimResponse = (await res.json());
+        registerResponse = (await res.json());
     }
     catch (err) {
         console.error(`Failed to reach server: ${err}`);
         process.exit(1);
     }
-    // 3. Save config
+    // Prompt for connection mode
+    const mode = await promptMode();
+    // Build config
     const config = {
-        agentId: claimResponse.agentId,
-        userId: claimResponse.userId,
-        natsUrl: claimResponse.natsUrl,
-        natsWsUrl: claimResponse.natsWsUrl,
-        natsToken: claimResponse.natsToken,
+        hostId: registerResponse.hostId,
         projectRoot: process.cwd(),
+        mode,
+        natsUrl: registerResponse.natsUrl,
+        natsWsUrl: registerResponse.natsWsUrl,
+        natsToken: registerResponse.natsToken,
     };
+    if (mode === "auto") {
+        const directToken = randomBytes(32).toString("hex");
+        const directPort = options.port ?? 7400;
+        const lanIp = options.host ?? detectLanIp();
+        config.directPort = directPort;
+        config.directToken = directToken;
+        console.log("");
+        console.log("Direct connection info (for LAN clients):");
+        console.log(`  Address: ${lanIp}:${directPort}`);
+        console.log(`  Token:   ${directToken}`);
+    }
+    console.log("Detecting installed agents...");
+    config.agents = await detectAgents();
     saveConfig(config);
-    console.log(`Agent provisioned. ID: ${config.agentId}`);
-    console.log("Config saved to ~/.config/palmier/agent.json");
-    // 4. Install systemd user service for palmier serve
+    console.log(`Host provisioned (${mode} mode). ID: ${config.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();
+}
+/**
+ * Prompt user to select connection mode.
+ */
+async function promptMode() {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const question = (q) => new Promise((resolve) => rl.question(q, resolve));
+    console.log("");
+    console.log("Connection mode:");
+    console.log("  1) auto — Both LAN and NATS (recommended)");
+    console.log("  2) nats — NATS only");
+    console.log("");
+    const answer = await question("Select [1]: ");
+    rl.close();
+    if (answer.trim() === "2" || answer.trim().toLowerCase() === "nats") {
+        return "nats";
+    }
+    return "auto";
+}
+/**
+ * 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";
+}
+/**
+ * Install systemd user service for palmier serve.
+ */
+function installSystemdService(config) {
     const unitDir = path.join(homedir(), ".config", "systemd", "user");
     fs.mkdirSync(unitDir, { recursive: true });
     const palmierBin = process.argv[1] || "palmier";
-    const serviceContent = `[Unit]
-Description=Palmier Agent
-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 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-agent.service");
+    const servicePath = path.join(unitDir, "palmier.service");
     fs.writeFileSync(servicePath, serviceContent, "utf-8");
     console.log("Systemd service installed at:", servicePath);
-    // 6. Enable and start the service
+    // Enable and start the service
     try {
         execSync("systemctl --user daemon-reload", { stdio: "inherit" });
-        execSync("systemctl --user enable --now palmier-agent.service", { stdio: "inherit" });
-        console.log("Palmier agent service enabled and started.");
+        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-agent.service");
+        console.error("You may need to start it manually: systemctl --user enable --now palmier.service");
     }
-    // 7. Enable lingering so service runs without active login session
+    // Enable lingering so service runs without active login session
     try {
         execSync(`loginctl enable-linger ${process.env.USER || ""}`, { stdio: "inherit" });
         console.log("Login lingering enabled.");
@@ -94,6 +184,6 @@ WantedBy=default.target
     catch (err) {
         console.error(`Warning: failed to enable linger: ${err}`);
     }
-    console.log("\nAgent initialization complete!");
+    console.log("\nHost initialization complete!");
 }
 //# sourceMappingURL=init.js.map

package/dist/commands/mcpserver.d.ts

@@ -0,0 +1,2 @@
+export declare function mcpserverCommand(): Promise<void>;
+//# sourceMappingURL=mcpserver.d.ts.map

package/dist/commands/mcpserver.js

@@ -0,0 +1,75 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { StringCodec } from "nats";
+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 sc = StringCodec();
+    const server = new McpServer({ name: "palmier", version: "1.0.0" }, { capabilities: { tools: {} } });
+    // send-email requires NATS — only register in nats/auto mode
+    if (nc) {
+        server.registerTool("send-email", {
+            description: "Send an email via the Palmier platform's SMTP relay",
+            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"),
+            },
+        }, 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,
+            };
+            try {
+                const subject = `host.${config.hostId}.email.send`;
+                const reply = await nc.request(subject, sc.encode(JSON.stringify(payload)), {
+                    timeout: 15_000,
+                });
+                const result = JSON.parse(sc.decode(reply.data));
+                if (result.ok) {
+                    return {
+                        content: [{ type: "text", text: `Email sent successfully (messageId: ${result.messageId})` }],
+                    };
+                }
+                else {
+                    return {
+                        content: [{ type: "text", text: `Failed to send email: ${result.error}` }],
+                        isError: true,
+                    };
+                }
+            }
+            catch (err) {
+                return {
+                    content: [{ type: "text", text: `Error sending email: ${err}` }],
+                    isError: true,
+                };
+            }
+        });
+    }
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Graceful shutdown
+    transport.onclose = async () => {
+        if (nc)
+            await nc.drain();
+    };
+}
+//# sourceMappingURL=mcpserver.js.map

package/dist/commands/pair.d.ts

@@ -0,0 +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).
+ */
+export declare function pairCommand(): Promise<void>;
+//# sourceMappingURL=pair.d.ts.map

package/dist/commands/pair.js

@@ -0,0 +1,140 @@
+import * as http from "node:http";
+import { StringCodec } from "nats";
+import { loadConfig } from "../config.js";
+import { connectNats } from "../nats-client.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
+function generateCode() {
+    const bytes = new Uint8Array(CODE_LENGTH);
+    crypto.getRandomValues(bytes);
+    return Array.from(bytes, (b) => CODE_CHARS[b % CODE_CHARS.length]).join("");
+}
+function buildPairResponse(config, label) {
+    const session = addSession(label);
+    const response = {
+        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.
+ */
+function lanPairRegister(port, code) {
+    const body = JSON.stringify({ code, expiryMs: EXPIRY_MS });
+    return new Promise((resolve) => {
+        const req = http.request({
+            hostname: "127.0.0.1",
+            port,
+            path: "/internal/pair-register",
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            timeout: EXPIRY_MS + 5000, // slightly longer than expiry
+        }, (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+                try {
+                    const result = JSON.parse(Buffer.concat(chunks).toString("utf-8"));
+                    resolve(result.paired);
+                }
+                catch {
+                    resolve(false);
+                }
+            });
+        });
+        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.end(body);
+    });
+}
+/**
+ * Generate an OTP code and wait for a PWA client to pair.
+ * Listens on NATS (nats/auto modes) and/or HTTP (lan/auto modes).
+ */
+export async function pairCommand() {
+    const config = loadConfig();
+    const code = generateCode();
+    const mode = config.mode ?? "nats";
+    let paired = false;
+    function onPaired() {
+        paired = true;
+        console.log("Paired successfully!");
+    }
+    const cleanups = [];
+    // Display pairing info
+    console.log("");
+    console.log("Enter this code in your Palmier app:");
+    console.log("");
+    console.log(`  ${code}`);
+    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(async () => {
+            sub.unsubscribe();
+            await nc.drain();
+        });
+        (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)));
+                }
+                onPaired();
+            }
+        })();
+    }
+    // LAN pairing — long-poll the running serve process
+    if (mode === "lan" || mode === "auto") {
+        const port = config.directPort ?? 7400;
+        (async () => {
+            const result = await lanPairRegister(port, code);
+            if (result)
+                onPaired();
+        })();
+    }
+    // Wait for pairing or timeout
+    const start = Date.now();
+    await new Promise((resolve) => {
+        const interval = setInterval(() => {
+            if (paired || Date.now() - start >= EXPIRY_MS) {
+                clearInterval(interval);
+                resolve();
+            }
+        }, 500);
+    });
+    // Cleanup
+    for (const cleanup of cleanups) {
+        await cleanup();
+    }
+    if (!paired) {
+        console.log("Code expired. Run `palmier pair` to try again.");
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=pair.js.map

package/dist/commands/plan-generation.md

@@ -0,0 +1,32 @@
+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:**

package/dist/commands/run.d.ts

@@ -1,4 +1,3 @@
-export type TaskEventType = "start" | "finish" | "abort" | "fail";
 /**
  * Execute a task by ID.
  */