palmier 0.8.0 → 0.8.3

package/src/transports/http-transport.ts

@@ -11,8 +11,6 @@ import { handleMcpRequest, getAgentName, getResourceSubscriptions } from "../mcp
 import { getTaskDir } from "../task.js";
 import { popEvent } from "../event-queues.js";
 
-// ── Bundled PWA asset serving ───────────────────────────────────────────
-
 interface CachedAsset {
   data: Buffer;
   contentType: string;
@@ -41,22 +39,18 @@ function guessContentType(urlPath: string): string {
   return CONTENT_TYPES[ext] ?? "application/octet-stream";
 }
 
-/**
- * Read a PWA asset from the bundled pwa/ directory, caching in memory.
- * Returns null if the file does not exist.
- */
 function getAsset(urlPath: string): CachedAsset | null {
   const cached = assetCache.get(urlPath);
   if (cached) return cached;
 
   const filePath = path.join(PWA_DIR, urlPath === "/" ? "index.html" : urlPath);
 
-  // Prevent path traversal
+  // Prevent path traversal.
   if (!filePath.startsWith(PWA_DIR)) return null;
 
   try {
     let data = fs.readFileSync(filePath);
-    // Inject marker into index HTML so the PWA can detect it's served by palmier
+    // Marker lets the PWA detect it's served by palmier.
     if (urlPath === "/") {
       const html = data.toString("utf-8").replace("</head>", "<script>window.__PALMIER_SERVE__=true</script></head>");
       data = Buffer.from(html, "utf-8");
@@ -90,10 +84,6 @@ export function detectLanIp(): string {
   return "127.0.0.1";
 }
 
-/**
- * Start the HTTP transport: server with RPC, SSE, PWA proxy, pairing, and
- * localhost-only agent endpoints (notify, request-input, confirmation, permission).
- */
 export async function startHttpTransport(
   config: HostConfig,
   handleRpc: (req: RpcMessage) => Promise<unknown>,
@@ -126,7 +116,6 @@ export async function startHttpTransport(
     resource.subscribe(() => broadcastResourceUpdated(resource.uri));
   }
 
-  // If a pairing code is provided, pre-register it
   if (pairingCode) {
     const EXPIRY_MS = 24 * 60 * 60 * 1000;
     const timer = setTimeout(() => { pendingPairs.delete(pairingCode); }, EXPIRY_MS);
@@ -171,9 +160,6 @@ export async function startHttpTransport(
     return addr === "127.0.0.1" || addr === "::1" || addr === "::ffff:127.0.0.1";
   }
 
-  /**
-   * Publish an event via NATS and SSE.
-   */
   async function publishEvent(taskId: string, payload: Record<string, unknown>): Promise<void> {
     const sc = StringCodec();
     const subject = `host-event.${config.hostId}.${taskId}`;
@@ -191,8 +177,6 @@ export async function startHttpTransport(
     const url = new URL(req.url ?? "/", `http://localhost:${port}`);
     const pathname = url.pathname;
 
-    // ── MCP streamable HTTP endpoint ──────────────────────────────────
-
     if (req.method === "POST" && pathname === "/mcp") {
       if (!isLocalhost(req)) { sendJson(res, 403, { error: "localhost only" }); return; }
       try {
@@ -204,7 +188,7 @@ export async function startHttpTransport(
           res.setHeader("Mcp-Session-Id", result.sessionId);
         }
         if (result.stream && sessionId) {
-          // Keep response open as SSE stream for server-initiated notifications
+          // Keep the response open as SSE for server-initiated notifications.
           res.writeHead(200, {
             "Content-Type": "text/event-stream",
             "Cache-Control": "no-cache",
@@ -227,8 +211,6 @@ export async function startHttpTransport(
       return;
     }
 
-    // ── Auto-generated REST endpoints from MCP tool registry ──────────
-
     if (req.method === "POST" && agentToolMap.has(pathname.slice(1))) {
       if (!isLocalhost(req)) { sendJson(res, 403, { error: "localhost only" }); return; }
       const tool = agentToolMap.get(pathname.slice(1))!;
@@ -258,8 +240,6 @@ export async function startHttpTransport(
       return;
     }
 
-    // ── Auto-generated REST endpoints from MCP resource registry ────
-
     const matchedResource = req.method === "GET" && agentResources.find((r) => r.restPath === pathname);
     if (matchedResource) {
       if (!isLocalhost(req)) { sendJson(res, 403, { error: "localhost only" }); return; }
@@ -280,8 +260,6 @@ export async function startHttpTransport(
       return;
     }
 
-    // ── Event queue pop (used by event-triggered palmier run) ─────────
-
     if (req.method === "POST" && pathname === "/task-event/pop") {
       if (!isLocalhost(req)) { sendJson(res, 403, { error: "localhost only" }); return; }
       const taskId = url.searchParams.get("taskId");
@@ -293,8 +271,6 @@ export async function startHttpTransport(
       return;
     }
 
-    // ── Localhost-only endpoints (no auth) ─────────────────────────────
-
     if (req.method === "POST" && pathname === "/event") {
       if (!isLocalhost(req)) { sendJson(res, 403, { error: "localhost only" }); return; }
       try {
@@ -334,8 +310,6 @@ export async function startHttpTransport(
       return;
     }
 
-    // ── POST /request-permission — held connection ──────────────────────
-
     if (req.method === "POST" && pathname === "/request-permission") {
       if (!isLocalhost(req)) { sendJson(res, 403, { error: "localhost only" }); return; }
       try {
@@ -376,8 +350,6 @@ export async function startHttpTransport(
       return;
     }
 
-    // ── Public pair endpoint — no auth, PWA posts pairing code here ────────
-
     if (req.method === "POST" && pathname === "/pair") {
       try {
         const body = await readBody(req);
@@ -404,16 +376,14 @@ export async function startHttpTransport(
       return;
     }
 
-    // ── PWA assets (on-the-fly, cached) ────────────────────────────────
-
-    // Skip service worker and manifest — they require HTTPS which LAN mode doesn't use
+    // Service worker and manifest require HTTPS, which LAN mode doesn't use.
     const SKIP = new Set(["/registerSW.js", "/service-worker.js", "/manifest.webmanifest"]);
 
     const isApiRoute = pathname === "/events" || pathname.startsWith("/rpc/");
     if (!isApiRoute) {
       if (SKIP.has(pathname)) { sendJson(res, 404, { error: "Not found" }); return; }
 
-      // Try exact path, then fall back to index.html (SPA routing)
+      // Fall back to index.html for SPA routing.
       let asset = getAsset(pathname);
       if (!asset && pathname !== "/") {
         asset = getAsset("/");
@@ -428,14 +398,12 @@ export async function startHttpTransport(
       return;
     }
 
-    // ── API endpoints require auth (localhost is trusted) ───────────────
-
+    // Localhost is trusted; all other API callers require a client token.
     if (!isLocalhost(req) && !checkAuth(req)) {
       sendJson(res, 401, { error: "Unauthorized" });
       return;
     }
 
-    // SSE event stream
     if (req.method === "GET" && pathname === "/events") {
       res.writeHead(200, {
         "Content-Type": "text/event-stream",
@@ -456,7 +424,6 @@ export async function startHttpTransport(
       return;
     }
 
-    // RPC endpoint: POST /rpc/<method>
     if (req.method === "POST" && pathname.startsWith("/rpc/")) {
       const method = pathname.slice("/rpc/".length);
       if (!method) { sendJson(res, 400, { error: "Missing RPC method" }); return; }

package/src/transports/nats-transport.ts

@@ -1,10 +1,6 @@
 import { StringCodec, type NatsConnection, type Msg, type Subscription } from "nats";
 import type { HostConfig, RpcMessage } from "../types.js";
 
-/**
- * Start the NATS transport using an existing connection.
- * Subscribe to RPC subjects and dispatch to handler.
- */
 export async function startNatsTransport(
   config: HostConfig,
   handleRpc: (req: RpcMessage) => Promise<unknown>,
@@ -16,7 +12,6 @@ export async function startNatsTransport(
   console.log(`[nats] Subscribing to: ${subject}`);
   const sub = nc.subscribe(subject);
 
-  // Graceful shutdown
   const shutdown = async () => {
     console.log("[nats] Shutting down...");
     sub.unsubscribe();
@@ -28,12 +23,11 @@ export async function startNatsTransport(
   process.on("SIGTERM", shutdown);
 
   async function processMessage(msg: Msg) {
-    // Derive RPC method from subject: ...rpc.<method parts>
+    // Subject format: ...rpc.<method parts>
     const subjectTokens = msg.subject.split(".");
     const rpcIdx = subjectTokens.indexOf("rpc");
     const method = rpcIdx >= 0 ? subjectTokens.slice(rpcIdx + 1).join(".") : "";
 
-    // Parse params from message body
     let params: Record<string, unknown> = {};
     if (msg.data && msg.data.length > 0) {
       const raw = sc.decode(msg.data).trim();
@@ -50,7 +44,7 @@ export async function startNatsTransport(
       }
     }
 
-    // Extract clientToken from params (PWA includes it in the payload)
+    // PWA includes the client token in the payload.
     const clientToken = typeof params.clientToken === "string" ? params.clientToken : undefined;
     delete params.clientToken;
 
@@ -72,7 +66,7 @@ export async function startNatsTransport(
 
   async function consumeSubscription(subscription: Subscription) {
     for await (const msg of subscription) {
-      // Handle RPC without blocking the message loop so heartbeats keep flowing
+      // Don't await — heartbeats must keep flowing while RPC runs.
       processMessage(msg);
     }
   }

package/src/types.ts

@@ -7,12 +7,10 @@ export interface HostConfig {
   natsJwt?: string;
   natsNkeySeed?: string;
 
-  // Detected agent CLIs
   agents?: Array<{ key: string; label: string; supportsPermissions: boolean; supportsYolo: boolean }>;
 
-  // HTTP server port (default 7256)
   httpPort?: number;
-  // Whether to accept non-localhost HTTP connections
+  /** Whether to accept non-localhost HTTP connections. */
   lanEnabled?: boolean;
 }
 
@@ -25,8 +23,8 @@ export interface TaskFrontmatter {
    * Task schedule.
    * - `crons`: `schedule_values` holds cron expressions (e.g. "0 9 * * *")
    * - `specific_times`: `schedule_values` holds local datetime strings (e.g. "2026-04-20T09:00")
-   * - `on_new_notification`: fires on each new Android notification from NATS; no `schedule_values`
-   * - `on_new_sms`: fires on each new SMS from NATS; no `schedule_values`
+   * - `on_new_notification`: fires on each new Android notification from NATS. Optional `schedule_values` holds a single-entry packageName filter; empty/unset matches any app.
+   * - `on_new_sms`: fires on each new SMS from NATS. Optional `schedule_values` holds a single-entry sender filter; compared after normalization (strip spaces/dashes/parens/plus, lowercase). Empty/unset matches any sender.
    */
   schedule_type?: "crons" | "specific_times" | "on_new_notification" | "on_new_sms";
   schedule_values?: string[];
@@ -50,11 +48,6 @@ export interface ParsedTask {
  */
 export type TaskRunningState = "started" | "finished" | "aborted" | "failed";
 
-/**
- * Persisted to `status.json` in the task directory. Used for crash detection
- * (checkStaleTasks) and abort signalling. Interactive request flows (confirmation,
- * permission, input) are handled via held HTTP connections on the serve daemon.
- */
 export interface TaskStatus {
   running_state: TaskRunningState;
   time_stamp: number;

package/src/update-checker.ts

@@ -12,10 +12,7 @@ const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "
 export const isDevBuild = fs.existsSync(path.join(packageRoot, ".git"));
 export const currentVersion = isDevBuild ? `${pkg.version}-dev` : pkg.version;
 
-/**
- * Run the update and restart the daemon.
- * Returns an error message if the update fails.
- */
+/** Returns an error message if the update fails. */
 export async function performUpdate(): Promise<string | null> {
   try {
     const { output, exitCode } = await spawnCommand("npm", ["update", "-g", "palmier"], {
@@ -28,7 +25,7 @@ export async function performUpdate(): Promise<string | null> {
       return `Update failed. Please run manually:\nnpm update -g palmier`;
     }
     console.log("[update] Update installed, restarting daemon...");
-    // Small delay to allow the RPC response to be sent
+    // Delay so the RPC response finishes sending first.
     setTimeout(() => {
       getPlatform().restartDaemon().catch((err) => {
         console.error("[update] Restart failed:", err);

package/test/task-parsing.test.ts

@@ -35,16 +35,15 @@ requires_confirmation: false
     assert.equal(result.frontmatter.agent, "claude");
   });
 
-  it("defaults triggers_enabled to true", () => {
+  it("defaults schedule_enabled to true", () => {
     const content = `---
 id: abc123
 user_prompt: Do something
-triggers: []
 requires_confirmation: false
 ---`;
 
     const result = parseTaskContent(content);
-    assert.equal(result.frontmatter.triggers_enabled, true);
+    assert.equal(result.frontmatter.schedule_enabled, true);
   });
 
   it("derives name from user_prompt when not specified", () => {

package/test/windows-xml.test.ts

@@ -1,55 +1,54 @@
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { triggerToXml, buildTaskXml } from "../src/platform/windows.js";
+import { scheduleValueToXml, buildTaskXml } from "../src/platform/windows.js";
 
-describe("triggerToXml", () => {
-  it("converts a once trigger to TimeTrigger", () => {
-    const xml = triggerToXml({ type: "once", value: "2026-03-28T09:00" });
+describe("scheduleValueToXml", () => {
+  it("converts a specific_times value to TimeTrigger", () => {
+    const xml = scheduleValueToXml("specific_times", "2026-03-28T09:00");
     assert.equal(xml, "<TimeTrigger><StartBoundary>2026-03-28T09:00:00</StartBoundary></TimeTrigger>");
   });
 
   it("converts hourly cron to TimeTrigger with PT1H repetition", () => {
-    const xml = triggerToXml({ type: "cron", value: "0 * * * *" });
+    const xml = scheduleValueToXml("crons", "0 * * * *");
     assert.ok(xml.includes("<Interval>PT1H</Interval>"), "should have hourly interval");
     assert.ok(xml.includes("<TimeTrigger>"), "should be a TimeTrigger");
   });
 
   it("converts daily cron to CalendarTrigger with DaysInterval", () => {
-    const xml = triggerToXml({ type: "cron", value: "30 9 * * *" });
+    const xml = scheduleValueToXml("crons", "30 9 * * *");
     assert.ok(xml.includes("<ScheduleByDay>"), "should use ScheduleByDay");
     assert.ok(xml.includes("<DaysInterval>1</DaysInterval>"), "should have interval 1");
     assert.ok(xml.includes("T09:30:00"), "should encode time as 09:30");
   });
 
   it("converts weekly cron to CalendarTrigger with DaysOfWeek", () => {
-    const xml = triggerToXml({ type: "cron", value: "0 10 * * 1" });
+    const xml = scheduleValueToXml("crons", "0 10 * * 1");
     assert.ok(xml.includes("<ScheduleByWeek>"), "should use ScheduleByWeek");
     assert.ok(xml.includes("<Monday />"), "day 1 should be Monday");
     assert.ok(xml.includes("T10:00:00"), "should encode time as 10:00");
   });
 
   it("converts weekly cron for Sunday (day 0)", () => {
-    const xml = triggerToXml({ type: "cron", value: "0 8 * * 0" });
+    const xml = scheduleValueToXml("crons", "0 8 * * 0");
     assert.ok(xml.includes("<Sunday />"), "day 0 should be Sunday");
   });
 
   it("converts weekly cron for Sunday (day 7)", () => {
-    const xml = triggerToXml({ type: "cron", value: "0 8 * * 7" });
+    const xml = scheduleValueToXml("crons", "0 8 * * 7");
     assert.ok(xml.includes("<Sunday />"), "day 7 should also be Sunday");
   });
 
   it("converts monthly cron to CalendarTrigger with DaysOfMonth", () => {
-    const xml = triggerToXml({ type: "cron", value: "0 14 15 * *" });
+    const xml = scheduleValueToXml("crons", "0 14 15 * *");
     assert.ok(xml.includes("<ScheduleByMonth>"), "should use ScheduleByMonth");
     assert.ok(xml.includes("<Day>15</Day>"), "should have day 15");
     assert.ok(xml.includes("T14:00:00"), "should encode time as 14:00");
-    // All months should be listed
     assert.ok(xml.includes("<January />"), "should include January");
     assert.ok(xml.includes("<December />"), "should include December");
   });
 
   it("throws on invalid cron expression", () => {
-    assert.throws(() => triggerToXml({ type: "cron", value: "bad" }), /Invalid cron/);
+    assert.throws(() => scheduleValueToXml("crons", "bad"), /Invalid cron/);
   });
 });