palmier 0.8.1 → 0.8.3

package/src/task.ts

@@ -3,9 +3,6 @@ import * as path from "path";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 import type { ParsedTask, TaskFrontmatter, TaskStatus, HistoryEntry, ConversationMessage } from "./types.js";
 
-/**
- * Parse a TASK.md file from the given task directory.
- */
 export function parseTaskFile(taskDir: string): ParsedTask {
   const filePath = path.join(taskDir, "TASK.md");
 
@@ -17,9 +14,6 @@ export function parseTaskFile(taskDir: string): ParsedTask {
   return parseTaskContent(content);
 }
 
-/**
- * Parse TASK.md content string into frontmatter + body.
- */
 export function parseTaskContent(content: string): ParsedTask {
   const fmRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
   const match = content.match(fmRegex);
@@ -41,10 +35,6 @@ export function parseTaskContent(content: string): ParsedTask {
   return { frontmatter };
 }
 
-/**
- * Write a TASK.md file to the given task directory.
- * Creates the directory if it doesn't exist.
- */
 export function writeTaskFile(taskDir: string, task: ParsedTask): void {
   fs.mkdirSync(taskDir, { recursive: true });
 
@@ -55,18 +45,11 @@ export function writeTaskFile(taskDir: string, task: ParsedTask): void {
   fs.writeFileSync(filePath, content, "utf-8");
 }
 
-/**
- * Append a task ID to the project-level tasks.jsonl file.
- */
 export function appendTaskList(projectRoot: string, taskId: string): void {
   const listPath = path.join(projectRoot, "tasks.jsonl");
   fs.appendFileSync(listPath, JSON.stringify({ task_id: taskId }) + "\n", "utf-8");
 }
 
-/**
- * Remove a task ID from the project-level tasks.jsonl file.
- * Returns true if the entry was found and removed.
- */
 export function removeFromTaskList(projectRoot: string, taskId: string): boolean {
   const listPath = path.join(projectRoot, "tasks.jsonl");
   if (!fs.existsSync(listPath)) return false;
@@ -91,9 +74,6 @@ export function removeFromTaskList(projectRoot: string, taskId: string): boolean
   return true;
 }
 
-/**
- * List all tasks referenced in tasks.jsonl.
- */
 export function listTasks(projectRoot: string): ParsedTask[] {
   const listPath = path.join(projectRoot, "tasks.jsonl");
   if (!fs.existsSync(listPath)) return [];
@@ -118,25 +98,15 @@ export function listTasks(projectRoot: string): ParsedTask[] {
   return tasks.reverse();
 }
 
-/**
- * Get the directory path for a task by its ID.
- */
 export function getTaskDir(projectRoot: string, taskId: string): string {
   return path.join(projectRoot, "tasks", taskId);
 }
 
-/**
- * Write task status to status.json in the task directory.
- */
 export function writeTaskStatus(taskDir: string, status: TaskStatus): void {
   const filePath = path.join(taskDir, "status.json");
   fs.writeFileSync(filePath, JSON.stringify(status), "utf-8");
 }
 
-/**
- * Read task status from status.json in the task directory.
- * Returns undefined if the file doesn't exist.
- */
 export function readTaskStatus(taskDir: string): TaskStatus | undefined {
   const filePath = path.join(taskDir, "status.json");
   try {
@@ -146,10 +116,7 @@ export function readTaskStatus(taskDir: string): TaskStatus | undefined {
   }
 }
 
-/**
- * Create a run directory with an initial TASKRUN.md file.
- * Returns the run ID (timestamp string used as directory name).
- */
+/** Returns the run ID (timestamp string used as directory name). */
 export function createRunDir(
   taskDir: string,
   taskName: string,
@@ -165,16 +132,10 @@ export function createRunDir(
   return runId;
 }
 
-/**
- * Get the path to a run directory.
- */
 export function getRunDir(taskDir: string, runId: string): string {
   return path.join(taskDir, runId);
 }
 
-/**
- * Append a conversation message to a run's TASKRUN.md file.
- */
 export function appendRunMessage(
   taskDir: string,
   runId: string,
@@ -189,10 +150,6 @@ export function appendRunMessage(
   fs.appendFileSync(path.join(taskDir, runId, "TASKRUN.md"), entry, "utf-8");
 }
 
-/**
- * Begin a streaming assistant message — writes the delimiter only.
- * Returns a writer that appends content chunks and finalizes the message.
- */
 export function beginStreamingMessage(
   taskDir: string,
   runId: string,
@@ -217,7 +174,7 @@ export class StreamingMessageWriter {
     fs.appendFileSync(this.filePath, "\n\n", "utf-8");
     if (attachments?.length) {
       const raw = fs.readFileSync(this.filePath, "utf-8");
-      // Find the last assistant delimiter (may differ from the original if spliceUserMessage created a new one)
+      // spliceUserMessage may have created a newer assistant delimiter.
       const pattern = /<!-- palmier:message role="assistant" time="\d+" -->/g;
       let lastMatch: RegExpExecArray | null = null;
       let m;
@@ -233,12 +190,10 @@ export class StreamingMessageWriter {
 }
 
 /**
- * Splice a user message into a running assistant stream.
- * Ends the current assistant block, writes the user message,
- * then opens a new assistant block — all as direct file appends.
- * The existing StreamingMessageWriter keeps working because its
- * write() is just appendFileSync, so subsequent chunks land in
- * the new assistant block.
+ * Splice a user message into a running assistant stream: close the current
+ * assistant block, write the user message, open a new assistant block. Direct
+ * appends only, so an existing StreamingMessageWriter keeps working — its
+ * subsequent chunks land in the new block.
  */
 export function spliceUserMessage(
   taskDir: string,
@@ -248,22 +203,15 @@ export function spliceUserMessage(
   assistantAppend?: string,
 ): void {
   const filePath = path.join(taskDir, runId, "TASKRUN.md");
-  // 1. Optionally append to the current assistant block (e.g. the input questions)
   if (assistantAppend) {
     fs.appendFileSync(filePath, assistantAppend, "utf-8");
   }
-  // 2. End the current assistant block
   fs.appendFileSync(filePath, "\n\n", "utf-8");
-  // 3. Write the user message
   appendRunMessage(taskDir, runId, userMsg);
-  // 4. Open a new assistant block for subsequent agent output
   const delimiter = `<!-- palmier:message role="assistant" time="${Date.now()}" -->`;
   fs.appendFileSync(filePath, `${delimiter}\n\n`, "utf-8");
 }
 
-/**
- * Read conversation messages from a run's TASKRUN.md file.
- */
 export function readRunMessages(taskDir: string, runId: string): ConversationMessage[] {
   const raw = fs.readFileSync(path.join(taskDir, runId, "TASKRUN.md"), "utf-8");
   const fmMatch = raw.match(/^---\n[\s\S]*?\n---\n([\s\S]*)$/);
@@ -298,18 +246,11 @@ export function readRunMessages(taskDir: string, runId: string): ConversationMes
   return messages;
 }
 
-/**
- * Append a history entry to the project-level history.jsonl file.
- */
 export function appendHistory(projectRoot: string, entry: HistoryEntry): void {
   const historyPath = path.join(projectRoot, "history.jsonl");
   fs.appendFileSync(historyPath, JSON.stringify(entry) + "\n", "utf-8");
 }
 
-/**
- * Delete a history entry and its associated run directory.
- * Returns true if the entry was found and removed.
- */
 export function deleteHistoryEntry(
   projectRoot: string,
   taskId: string,
@@ -337,7 +278,6 @@ export function deleteHistoryEntry(
 
   fs.writeFileSync(historyPath, remaining.length > 0 ? remaining.join("\n") + "\n" : "", "utf-8");
 
-  // Delete the run directory
   const runDir = path.join(projectRoot, "tasks", taskId, runId);
   if (fs.existsSync(runDir)) {
     fs.rmSync(runDir, { recursive: true, force: true });
@@ -346,10 +286,7 @@ export function deleteHistoryEntry(
   return true;
 }
 
-/**
- * Read history entries from history.jsonl with pagination.
- * Returns entries sorted most-recent-first.
- */
+/** Returns entries most-recent-first. */
 export function readHistory(
   projectRoot: string,
   opts: { offset?: number; limit?: number; task_id?: string },

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/);
   });
 });