palmier 0.8.1 → 0.8.4

package/dist/platform/macos.js

@@ -0,0 +1,287 @@
+import * as fs from "fs";
+import * as path from "path";
+import { homedir } from "os";
+import { execSync, exec } from "child_process";
+import { promisify } from "util";
+import { CONFIG_DIR, loadConfig } from "../config.js";
+import { getTaskDir, readTaskStatus } from "../task.js";
+const execAsync = promisify(exec);
+const AGENT_DIR = path.join(homedir(), "Library", "LaunchAgents");
+const PATH_FILE = path.join(CONFIG_DIR, "user-path");
+const DAEMON_LABEL = "me.palmier.host";
+const TASK_LABEL_PREFIX = "me.palmier.task.";
+function daemonPlistPath() {
+    return path.join(AGENT_DIR, `${DAEMON_LABEL}.plist`);
+}
+function taskLabel(taskId) {
+    return `${TASK_LABEL_PREFIX}${taskId}`;
+}
+function taskPlistPath(taskId) {
+    return path.join(AGENT_DIR, `${taskLabel(taskId)}.plist`);
+}
+function guiDomain() {
+    const uid = process.getuid?.();
+    if (uid === undefined)
+        throw new Error("getuid() unavailable — macOS platform requires POSIX uid");
+    return `gui/${uid}`;
+}
+/**
+ * Convert one of the four PWA-produced cron patterns to a launchd
+ * `StartCalendarInterval` dict.
+ *   hourly  "0 * * * *"        → { Minute: 0 }
+ *   daily   "MM HH * * *"      → { Minute, Hour }
+ *   weekly  "MM HH * * D"      → { Minute, Hour, Weekday }
+ *   monthly "MM HH D * *"      → { Minute, Hour, Day }
+ * launchd Weekday: Sunday is 0 (cron 7 → 0).
+ */
+export function cronToCalendarInterval(cron) {
+    const parts = cron.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        throw new Error(`Invalid cron expression (expected 5 fields): ${cron}`);
+    }
+    const [minute, hour, dayOfMonth, , dayOfWeek] = parts;
+    const result = {};
+    if (minute !== "*")
+        result.Minute = Number(minute);
+    if (hour !== "*")
+        result.Hour = Number(hour);
+    if (dayOfMonth !== "*")
+        result.Day = Number(dayOfMonth);
+    if (dayOfWeek !== "*") {
+        const dow = Number(dayOfWeek);
+        result.Weekday = dow === 7 ? 0 : dow;
+    }
+    for (const [k, v] of Object.entries(result)) {
+        if (!Number.isInteger(v) || v < 0) {
+            throw new Error(`Invalid cron field ${k}=${v} in ${cron}`);
+        }
+    }
+    return result;
+}
+/**
+ * Convert a PWA `specific_times` value (ISO local datetime like "2026-04-20T09:00")
+ * to a `StartCalendarInterval` dict. launchd has no "one-shot at date X" trigger,
+ * so we omit Year — the task fires yearly on the same date and time. Sufficient
+ * because the PWA regenerates/removes one-off tasks after they run.
+ */
+export function specificTimeToCalendarInterval(iso) {
+    const m = iso.match(/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})/);
+    if (!m)
+        throw new Error(`Invalid specific_times value: ${iso}`);
+    return {
+        Month: Number(m[2]),
+        Day: Number(m[3]),
+        Hour: Number(m[4]),
+        Minute: Number(m[5]),
+    };
+}
+function escapeXml(s) {
+    return s
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+/** Serialize a JS value to a plist XML fragment. Supports string/number/boolean/array/plain object. */
+function plistValue(value, indent) {
+    if (typeof value === "string")
+        return `${indent}<string>${escapeXml(value)}</string>`;
+    if (typeof value === "boolean")
+        return `${indent}<${value ? "true" : "false"}/>`;
+    if (typeof value === "number") {
+        return Number.isInteger(value)
+            ? `${indent}<integer>${value}</integer>`
+            : `${indent}<real>${value}</real>`;
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return `${indent}<array/>`;
+        const inner = value.map((v) => plistValue(v, indent + "  ")).join("\n");
+        return `${indent}<array>\n${inner}\n${indent}</array>`;
+    }
+    if (value && typeof value === "object") {
+        const entries = Object.entries(value);
+        if (entries.length === 0)
+            return `${indent}<dict/>`;
+        const inner = entries
+            .map(([k, v]) => `${indent}  <key>${escapeXml(k)}</key>\n${plistValue(v, indent + "  ")}`)
+            .join("\n");
+        return `${indent}<dict>\n${inner}\n${indent}</dict>`;
+    }
+    throw new Error(`Unsupported plist value type: ${typeof value}`);
+}
+export function buildPlist(dict) {
+    return [
+        `<?xml version="1.0" encoding="UTF-8"?>`,
+        `<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">`,
+        `<plist version="1.0">`,
+        plistValue(dict, ""),
+        `</plist>`,
+        ``,
+    ].join("\n");
+}
+function runLaunchctl(args, opts = {}) {
+    try {
+        execSync(`launchctl ${args.join(" ")}`, { stdio: "pipe", encoding: "utf-8" });
+    }
+    catch (err) {
+        if (opts.ignoreFailure)
+            return;
+        const e = err;
+        console.error(`launchctl ${args[0]} failed: ${e.stderr || err}`);
+    }
+}
+export class MacOsPlatform {
+    installDaemon(config) {
+        fs.mkdirSync(AGENT_DIR, { recursive: true });
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        const palmierBin = process.argv[1] || "palmier";
+        const userPath = process.env.PATH || "/usr/local/bin:/usr/bin:/bin";
+        fs.writeFileSync(PATH_FILE, userPath, "utf-8");
+        const logPath = path.join(CONFIG_DIR, "daemon.log");
+        const plist = buildPlist({
+            Label: DAEMON_LABEL,
+            ProgramArguments: [process.execPath, palmierBin, "serve"],
+            WorkingDirectory: config.projectRoot,
+            RunAtLoad: true,
+            KeepAlive: { SuccessfulExit: false },
+            EnvironmentVariables: { PATH: userPath },
+            StandardOutPath: logPath,
+            StandardErrorPath: logPath,
+        });
+        const plistPath = daemonPlistPath();
+        fs.writeFileSync(plistPath, plist, "utf-8");
+        console.log("LaunchAgent installed at:", plistPath);
+        const domain = guiDomain();
+        runLaunchctl(["bootout", `${domain}/${DAEMON_LABEL}`], { ignoreFailure: true });
+        runLaunchctl(["bootstrap", domain, `"${plistPath}"`]);
+        runLaunchctl(["kickstart", "-k", `${domain}/${DAEMON_LABEL}`]);
+        console.log("Palmier host LaunchAgent loaded and started.");
+        console.log("Note: LaunchAgents only run while you are logged into the GUI session. " +
+            "After reboot, tasks remain dormant until you log in at least once.");
+        console.log("\nHost initialization complete!");
+    }
+    uninstallDaemon() {
+        const domain = guiDomain();
+        runLaunchctl(["bootout", `${domain}/${DAEMON_LABEL}`], { ignoreFailure: true });
+        try {
+            fs.unlinkSync(daemonPlistPath());
+        }
+        catch { /* may not exist */ }
+        try {
+            const entries = fs.readdirSync(AGENT_DIR).filter((f) => f.startsWith(TASK_LABEL_PREFIX) && f.endsWith(".plist"));
+            for (const f of entries) {
+                const label = f.slice(0, -".plist".length);
+                runLaunchctl(["bootout", `${domain}/${label}`], { ignoreFailure: true });
+                try {
+                    fs.unlinkSync(path.join(AGENT_DIR, f));
+                }
+                catch { /* ignore */ }
+            }
+        }
+        catch { /* AGENT_DIR may not exist */ }
+        console.log("Palmier daemon and tasks uninstalled.");
+    }
+    async restartDaemon() {
+        const plistPath = daemonPlistPath();
+        const domain = guiDomain();
+        if (process.stdin.isTTY && fs.existsSync(plistPath)) {
+            fs.mkdirSync(CONFIG_DIR, { recursive: true });
+            const userPath = process.env.PATH || "";
+            fs.writeFileSync(PATH_FILE, userPath, "utf-8");
+            const content = fs.readFileSync(plistPath, "utf-8");
+            const updated = content.replace(/(<key>PATH<\/key>\s*\n\s*<string>)[^<]*(<\/string>)/, `$1${escapeXml(userPath)}$2`);
+            if (updated !== content) {
+                fs.writeFileSync(plistPath, updated, "utf-8");
+                runLaunchctl(["bootout", `${domain}/${DAEMON_LABEL}`], { ignoreFailure: true });
+                runLaunchctl(["bootstrap", domain, `"${plistPath}"`]);
+            }
+        }
+        runLaunchctl(["kickstart", "-k", `${domain}/${DAEMON_LABEL}`]);
+        console.log("Palmier daemon restarted.");
+    }
+    installTaskTimer(config, task) {
+        fs.mkdirSync(AGENT_DIR, { recursive: true });
+        const taskId = task.frontmatter.id;
+        const label = taskLabel(taskId);
+        const plistPath = taskPlistPath(taskId);
+        const palmierBin = process.argv[1] || "palmier";
+        const dict = {
+            Label: label,
+            ProgramArguments: [process.execPath, palmierBin, "run", taskId],
+            WorkingDirectory: config.projectRoot,
+            RunAtLoad: false,
+            EnvironmentVariables: { PATH: process.env.PATH || "/usr/local/bin:/usr/bin:/bin" },
+        };
+        const scheduleType = task.frontmatter.schedule_type;
+        const scheduleValues = task.frontmatter.schedule_values;
+        const isTimerSchedule = scheduleType === "crons" || scheduleType === "specific_times";
+        if (task.frontmatter.schedule_enabled && isTimerSchedule && scheduleValues?.length) {
+            const intervals = [];
+            for (const value of scheduleValues) {
+                try {
+                    intervals.push(scheduleType === "crons"
+                        ? cronToCalendarInterval(value)
+                        : specificTimeToCalendarInterval(value));
+                }
+                catch (err) {
+                    console.error(`Invalid schedule value: ${err}`);
+                }
+            }
+            if (intervals.length > 0)
+                dict.StartCalendarInterval = intervals;
+        }
+        fs.writeFileSync(plistPath, buildPlist(dict), "utf-8");
+        const domain = guiDomain();
+        runLaunchctl(["bootout", `${domain}/${label}`], { ignoreFailure: true });
+        runLaunchctl(["bootstrap", domain, `"${plistPath}"`]);
+    }
+    removeTaskTimer(taskId) {
+        const domain = guiDomain();
+        runLaunchctl(["bootout", `${domain}/${taskLabel(taskId)}`], { ignoreFailure: true });
+        try {
+            fs.unlinkSync(taskPlistPath(taskId));
+        }
+        catch { /* ignore */ }
+    }
+    async startTask(taskId) {
+        await execAsync(`launchctl kickstart ${guiDomain()}/${taskLabel(taskId)}`);
+    }
+    async stopTask(taskId) {
+        try {
+            const taskDir = getTaskDir(loadConfig().projectRoot, taskId);
+            const status = readTaskStatus(taskDir);
+            if (status?.pid) {
+                process.kill(status.pid, "SIGTERM");
+                return;
+            }
+        }
+        catch { /* fall through */ }
+        await execAsync(`launchctl kill SIGTERM ${guiDomain()}/${taskLabel(taskId)}`);
+    }
+    isTaskRunning(taskId) {
+        try {
+            const out = execSync(`launchctl print ${guiDomain()}/${taskLabel(taskId)}`, {
+                encoding: "utf-8",
+                stdio: ["ignore", "pipe", "ignore"],
+            });
+            // Running services show a numeric `pid = N`; idle ones show `state = not running`.
+            if (/^\s*pid\s*=\s*\d+/m.test(out))
+                return true;
+        }
+        catch { /* service may not be loaded */ }
+        try {
+            const taskDir = getTaskDir(loadConfig().projectRoot, taskId);
+            const status = readTaskStatus(taskDir);
+            if (status?.pid) {
+                process.kill(status.pid, 0);
+                return true;
+            }
+        }
+        catch { /* process not running or config unavailable */ }
+        return false;
+    }
+    getGuiEnv() {
+        return {};
+    }
+}
+//# sourceMappingURL=macos.js.map

package/dist/platform/platform.d.ts

@@ -1,8 +1,5 @@
 import type { HostConfig, ParsedTask } from "../types.js";
-/**
- * Abstracts OS-specific daemon, scheduling, and process management.
- * Linux uses systemd; Windows uses Task Scheduler; macOS will use launchd.
- */
+/** Linux: systemd. Windows: Task Scheduler. macOS: launchd (planned). */
 export interface PlatformService {
     /** Install the main `palmier serve` daemon to start at boot. */
     installDaemon(config: HostConfig): void;

package/dist/platform/windows.d.ts

@@ -12,17 +12,14 @@ import type { HostConfig, ParsedTask } from "../types.js";
  *   monthly: "MM HH D * *"
  */
 export declare function scheduleValueToXml(scheduleType: "crons" | "specific_times", value: string): string;
-/**
- * Build a complete Task Scheduler XML definition.
- */
 export declare function buildTaskXml(tr: string, triggers: string[], foreground?: boolean): string;
 export declare class WindowsPlatform implements PlatformService {
     installDaemon(config: HostConfig): void;
     uninstallDaemon(): void;
     restartDaemon(): Promise<void>;
-    /** Create or update the Task Scheduler entry for the daemon (requires elevation for S4U). */
+    /** S4U LogonType requires elevation to create. */
     private ensureDaemonTask;
-    /** Start the daemon via Task Scheduler (runs outside any session's job object). */
+    /** Starting via Task Scheduler runs the daemon outside any session's job object. */
     private startDaemonTask;
     installTaskTimer(config: HostConfig, task: ParsedTask): void;
     removeTaskTimer(taskId: string): void;

package/dist/platform/windows.js

@@ -26,27 +26,20 @@ export function scheduleValueToXml(scheduleType, value) {
         throw new Error(`Invalid cron expression: ${value}`);
     const [minute, hour, dayOfMonth, , dayOfWeek] = parts;
     const st = `${hour.padStart(2, "0")}:${minute.padStart(2, "0")}:00`;
-    // StartBoundary needs a full date; use a past date as the anchor
+    // StartBoundary needs a full date; anchor to a past one.
     const base = `2000-01-01T${st}`;
-    // Hourly
     if (hour === "*") {
         return `<TimeTrigger><StartBoundary>${base}</StartBoundary><Repetition><Interval>PT1H</Interval></Repetition></TimeTrigger>`;
     }
-    // Weekly
     if (dayOfMonth === "*" && dayOfWeek !== "*") {
         const day = DOW_NAMES[Number(dayOfWeek)] ?? "Monday";
         return `<CalendarTrigger><StartBoundary>${base}</StartBoundary><ScheduleByWeek><DaysOfWeek><${day} /></DaysOfWeek><WeeksInterval>1</WeeksInterval></ScheduleByWeek></CalendarTrigger>`;
     }
-    // Monthly
     if (dayOfMonth !== "*" && dayOfWeek === "*") {
         return `<CalendarTrigger><StartBoundary>${base}</StartBoundary><ScheduleByMonth><DaysOfMonth><Day>${dayOfMonth}</Day></DaysOfMonth><Months><January /><February /><March /><April /><May /><June /><July /><August /><September /><October /><November /><December /></Months></ScheduleByMonth></CalendarTrigger>`;
     }
-    // Daily
     return `<CalendarTrigger><StartBoundary>${base}</StartBoundary><ScheduleByDay><DaysInterval>1</DaysInterval></ScheduleByDay></CalendarTrigger>`;
 }
-/**
- * Build a complete Task Scheduler XML definition.
- */
 export function buildTaskXml(tr, triggers, foreground) {
     const [command, ...argParts] = tr.match(/"[^"]*"|[^\s]+/g) ?? [];
     const commandStr = command?.replace(/"/g, "") ?? "";
@@ -82,20 +75,17 @@ function schtasksTaskName(taskId) {
 export class WindowsPlatform {
     installDaemon(config) {
         const script = process.argv[1] || "palmier";
-        // Create the Task Scheduler entry for the daemon (BootTrigger starts it at system boot)
         this.ensureDaemonTask(script);
-        // Start the daemon now
         this.startDaemonTask();
         console.log("\nHost initialization complete!");
     }
     uninstallDaemon() {
         const tn = `\\Palmier\\${DAEMON_TASK_NAME}`;
-        // Stop the daemon via Task Scheduler
         try {
             execFileSync("schtasks", ["/end", "/tn", tn], { encoding: "utf-8", windowsHide: true, stdio: "pipe" });
         }
         catch { /* task may not be running */ }
-        // Remove daemon scheduled task (elevated — S4U task requires elevation to delete)
+        // Deleting an S4U task requires elevation.
         try {
             execFileSync("powershell", [
                 "-Command", `Start-Process -Verb RunAs -Wait -FilePath schtasks -ArgumentList '/delete /tn "${tn}" /f'`,
@@ -103,7 +93,6 @@ export class WindowsPlatform {
             console.log("Daemon task removed.");
         }
         catch { /* task may not exist */ }
-        // Remove all Palmier task timers
         try {
             const out = execFileSync("schtasks", ["/query", "/fo", "CSV", "/nh"], { encoding: "utf-8", windowsHide: true, stdio: "pipe" });
             for (const line of out.split("\n")) {
@@ -126,15 +115,13 @@ export class WindowsPlatform {
     }
     async restartDaemon() {
         const tn = `\\Palmier\\${DAEMON_TASK_NAME}`;
-        // Stop the daemon via Task Scheduler
         try {
             execFileSync("schtasks", ["/end", "/tn", tn], { encoding: "utf-8", windowsHide: true, stdio: "pipe" });
         }
         catch { /* task may not be running */ }
-        // Start it again
         this.startDaemonTask();
     }
-    /** Create or update the Task Scheduler entry for the daemon (requires elevation for S4U). */
+    /** S4U LogonType requires elevation to create. */
     ensureDaemonTask(script) {
         const tn = `\\Palmier\\${DAEMON_TASK_NAME}`;
         const tr = `"${process.execPath}" "${script}" serve`;
@@ -143,7 +130,7 @@ export class WindowsPlatform {
         try {
             const bom = Buffer.from([0xFF, 0xFE]);
             fs.writeFileSync(xmlPath, Buffer.concat([bom, Buffer.from(xml, "utf16le")]));
-            // S4U LogonType requires elevation — spawn schtasks via RunAs
+            // S4U requires elevation — spawn schtasks via RunAs.
             const args = `/create /tn "${tn}" /xml "${xmlPath}" /f`;
             execFileSync("powershell", [
                 "-Command", `Start-Process -Verb RunAs -Wait -FilePath schtasks -ArgumentList '${args}'`,
@@ -160,7 +147,7 @@ export class WindowsPlatform {
             catch { /* ignore */ }
         }
     }
-    /** Start the daemon via Task Scheduler (runs outside any session's job object). */
+    /** Starting via Task Scheduler runs the daemon outside any session's job object. */
     startDaemonTask() {
         const tn = `\\Palmier\\${DAEMON_TASK_NAME}`;
         try {
@@ -177,9 +164,8 @@ export class WindowsPlatform {
         const tn = schtasksTaskName(taskId);
         const script = process.argv[1] || "palmier";
         const tr = `"${process.execPath}" "${script}" run ${taskId}`;
-        // Build trigger XML elements. Event-based schedule types (on_new_notification,
-        // on_new_sms) carry no values and are driven by the run process, not the OS
-        // scheduler — they intentionally produce only the dummy trigger below.
+        // Event-based schedule types (on_new_notification/on_new_sms) are driven by
+        // the run process, not the OS scheduler — they fall through to the dummy trigger.
         const triggerElements = [];
         const scheduleType = task.frontmatter.schedule_type;
         const scheduleValues = task.frontmatter.schedule_values;
@@ -194,18 +180,18 @@ export class WindowsPlatform {
                 }
             }
         }
-        // Always include a dummy trigger so startTask (/run) works
+        // Dummy trigger so schtasks /run still works.
         if (triggerElements.length === 0) {
             triggerElements.push(`<TimeTrigger><StartBoundary>2000-01-01T00:00:00</StartBoundary></TimeTrigger>`);
         }
-        // Write XML and register via schtasks — gives us full control over
-        // settings like MultipleInstancesPolicy that schtasks flags don't expose.
-        // S4U LogonType ensures no console window (unless foreground_mode is set).
-        // Works without elevation because the daemon (which calls this) runs elevated.
+        // XML registration (vs schtasks flags) gives us access to settings like
+        // MultipleInstancesPolicy. S4U keeps the console hidden unless
+        // foreground_mode is set. Works unelevated because the caller (daemon)
+        // runs elevated.
         const xml = buildTaskXml(tr, triggerElements, task.frontmatter.foreground_mode);
         const xmlPath = path.join(CONFIG_DIR, `task-${taskId}.xml`);
         try {
-            // schtasks /xml requires UTF-16LE with BOM
+            // schtasks /xml requires UTF-16LE with BOM.
             const bom = Buffer.from([0xFF, 0xFE]);
             fs.writeFileSync(xmlPath, Buffer.concat([bom, Buffer.from(xml, "utf16le")]));
             execFileSync("schtasks", [
@@ -228,9 +214,7 @@ export class WindowsPlatform {
         try {
             execFileSync("schtasks", ["/delete", "/tn", tn, "/f"], { encoding: "utf-8", windowsHide: true });
         }
-        catch {
-            // Task might not exist — that's fine
-        }
+        catch { /* task may not exist */ }
     }
     async startTask(taskId) {
         const tn = schtasksTaskName(taskId);
@@ -243,8 +227,8 @@ export class WindowsPlatform {
         }
     }
     async stopTask(taskId) {
-        // Try to kill the entire process tree via the PID recorded in status.json.
-        // schtasks /end only kills the top-level process, leaving agent children orphaned.
+        // schtasks /end leaves agent children orphaned, so kill the process tree
+        // via the PID recorded in status.json first.
         try {
             const taskDir = getTaskDir(loadConfig().projectRoot, taskId);
             const status = readTaskStatus(taskDir);
@@ -254,9 +238,8 @@ export class WindowsPlatform {
             }
         }
         catch {
-            // PID may be stale or config unavailable; fall through to schtasks /end
+            // PID may be stale or config unavailable; fall through to schtasks /end.
         }
-        // Fallback: schtasks /end (kills top-level process only)
         const tn = schtasksTaskName(taskId);
         try {
             execFileSync("schtasks", ["/end", "/tn", tn], { encoding: "utf-8", windowsHide: true });
@@ -267,7 +250,6 @@ export class WindowsPlatform {
         }
     }
     isTaskRunning(taskId) {
-        // Check Task Scheduler first (for scheduled/on-demand runs)
         const tn = schtasksTaskName(taskId);
         try {
             const out = execFileSync("schtasks", ["/query", "/tn", tn, "/fo", "CSV", "/nh"], {
@@ -278,18 +260,17 @@ export class WindowsPlatform {
                 return true;
         }
         catch { /* task may not exist in scheduler */ }
-        // Fall back to PID check (for follow-up runs spawned directly, not via schtasks)
+        // Follow-up runs are spawned directly (not via schtasks), so check PID too.
         try {
             const taskDir = getTaskDir(loadConfig().projectRoot, taskId);
             const status = readTaskStatus(taskDir);
             if (status?.pid) {
-                // tasklist exits 0 if the PID is found
                 execFileSync("tasklist", ["/fi", `PID eq ${status.pid}`, "/nh"], {
                     encoding: "utf-8",
                     windowsHide: true,
                     stdio: "pipe",
                 });
-                // tasklist always exits 0; check if output contains the PID
+                // tasklist always exits 0, so match the output for the PID.
                 const out = execFileSync("tasklist", ["/fi", `PID eq ${status.pid}`, "/fo", "CSV", "/nh"], {
                     encoding: "utf-8",
                     windowsHide: true,
@@ -303,7 +284,6 @@ export class WindowsPlatform {
         return false;
     }
     getGuiEnv() {
-        // Windows GUI is always available — no special env vars needed
         return {};
     }
 }