palmier 0.2.0 → 0.2.1

package/src/commands/pair.ts

@@ -0,0 +1,195 @@
+import * as os from "os";
+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";
+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
+
+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 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;
+      }
+    }
+  }
+  return "127.0.0.1";
+}
+
+function buildPairResponse(config: HostConfig, label?: string) {
+  const session = addSession(label);
+  const response: Record<string, unknown> = {
+    hostId: config.hostId,
+    sessionToken: session.token,
+  };
+
+  if (config.mode === "lan" || config.mode === "auto") {
+    const ip = detectLanIp();
+    response.directUrl = `http://${ip}:${config.directPort ?? 7400}`;
+    response.directToken = config.directToken;
+  }
+
+  return response;
+}
+
+/**
+ * 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(): Promise<void> {
+  const config = loadConfig();
+  const code = generateCode();
+  const mode = config.mode ?? "nats";
+
+  let paired = false;
+
+  function onPaired() {
+    paired = true;
+    console.log("Paired successfully!");
+  }
+
+  const cleanups: Array<() => void | Promise<void>> = [];
+
+  // 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: 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 */ }
+
+        const response = buildPairResponse(config, label);
+        if (msg.reply) {
+          msg.respond(sc.encode(JSON.stringify(response)));
+        }
+        onPaired();
+      }
+    })();
+  }
+
+  // HTTP pairing (lan or auto mode)
+  if (mode === "lan" || mode === "auto") {
+    const port = config.directPort ?? 7400;
+    const server = http.createServer(async (req, res) => {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+      res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+
+      if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+
+      if (req.method === "POST" && req.url === "/pair") {
+        const chunks: Buffer[] = [];
+        req.on("data", (chunk: Buffer) => chunks.push(chunk));
+        req.on("end", () => {
+          try {
+            const body = JSON.parse(Buffer.concat(chunks).toString("utf-8")) as {
+              code: string;
+              label?: string;
+            };
+
+            if (body.code !== code) {
+              res.writeHead(401, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ error: "Invalid code" }));
+              return;
+            }
+
+            if (paired) {
+              res.writeHead(410, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ error: "Code already used" }));
+              return;
+            }
+
+            const response = buildPairResponse(config, body.label);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(response));
+            onPaired();
+          } catch {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Invalid JSON" }));
+          }
+        });
+        return;
+      }
+
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not found" }));
+    });
+
+    await new Promise<void>((resolve, reject) => {
+      server.listen(port + 1, () => resolve());
+      server.on("error", reject);
+    });
+
+    cleanups.push(() => {
+      server.close();
+    });
+  }
+
+  // Display pairing info
+  console.log("");
+  console.log("Enter this code in your Palmier app:");
+  console.log("");
+  console.log(`  ${code}`);
+  console.log("");
+
+  if (mode === "lan" || mode === "auto") {
+    const ip = detectLanIp();
+    const port = config.directPort ?? 7400;
+    console.log(`  Address: ${ip}:${port + 1}`);
+    console.log("");
+  }
+
+  console.log("Code expires in 5 minutes.");
+
+  // Wait for pairing or timeout
+  const start = Date.now();
+  await new Promise<void>((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);
+  }
+}

package/src/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:**