palmier 0.8.1 → 0.8.4

package/src/pending-requests.ts

@@ -22,10 +22,9 @@ export interface PendingRequest {
 const pending = new Map<string, PendingRequest>();
 
 /**
- * Register a pending request keyed by either a sessionId (confirmation / input)
- * or a taskId (permission). The `meta` is surfaced to PWAs that connect after
- * the request was opened, so their modals can render without replaying events.
- * Only one pending request per key at a time.
+ * Key is sessionId for confirmation/input, taskId for permission. Only one
+ * pending request per key at a time. `meta` is surfaced via host.info so a
+ * freshly-connected PWA can render the modal without replaying events.
  */
 export function registerPending(
   key: string,
@@ -42,10 +41,6 @@ export function registerPending(
   });
 }
 
-/**
- * Resolve a pending request with the user's response.
- * Returns true if a pending request was found and resolved.
- */
 export function resolvePending(key: string, value: string[]): boolean {
   const entry = pending.get(key);
   if (!entry) return false;
@@ -54,24 +49,15 @@ export function resolvePending(key: string, value: string[]): boolean {
   return true;
 }
 
-/**
- * Get the current pending request for a key (if any).
- */
 export function getPending(key: string): PendingRequest | undefined {
   return pending.get(key);
 }
 
-/**
- * Remove a pending request without resolving it.
- */
 export function removePending(key: string): void {
   pending.delete(key);
 }
 
-/**
- * List all currently-pending requests, stripped of the unserializable `resolve`
- * callback. Used by `host.info` so the PWA can seed its modal state on connect.
- */
+/** Pending requests stripped of the unserializable `resolve` callback. */
 export function listPending(): Array<{
   key: string;
   type: PendingRequest["type"];

package/src/platform/index.ts

@@ -1,20 +1,18 @@
 import type { PlatformService } from "./platform.js";
 import { LinuxPlatform } from "./linux.js";
 import { WindowsPlatform } from "./windows.js";
+import { MacOsPlatform } from "./macos.js";
 
-/**
- * On Windows, execSync needs an explicit shell so .cmd shims resolve correctly.
- * On Unix, undefined lets Node use the default shell.
- */
+/** Windows needs an explicit shell for execSync to resolve .cmd shims. */
 export const SHELL: string | undefined = process.platform === "win32" ? "cmd.exe" : undefined;
 
 let _instance: PlatformService | undefined;
 
 export function getPlatform(): PlatformService {
   if (!_instance) {
-    _instance = process.platform === "win32"
-      ? new WindowsPlatform()
-      : new LinuxPlatform();
+    if (process.platform === "win32") _instance = new WindowsPlatform();
+    else if (process.platform === "darwin") _instance = new MacOsPlatform();
+    else _instance = new LinuxPlatform();
   }
   return _instance;
 }

package/src/platform/linux.ts

@@ -22,15 +22,9 @@ function getServiceName(taskId: string): string {
 }
 
 /**
- * Convert a cron expression to a systemd OnCalendar string.
- *
- * Only the 4 cron patterns the PWA UI can produce are supported:
- *   hourly:  "0 * * * *"
- *   daily:   "MM HH * * *"
- *   weekly:  "MM HH * * D"
- *   monthly: "MM HH D * *"
- * Arbitrary cron expressions (ranges, lists, steps beyond hourly) are NOT
- * handled because the UI never generates them.
+ * Only the 4 cron patterns the PWA UI produces are supported:
+ *   hourly "0 * * * *", daily "MM HH * * *", weekly "MM HH * * D", monthly "MM HH D * *".
+ * Arbitrary expressions (ranges, lists, sub-hour steps) are not handled.
  */
 export function cronToOnCalendar(cron: string): string {
   const parts = cron.trim().split(/\s+/);
@@ -40,7 +34,6 @@ export function cronToOnCalendar(cron: string): string {
 
   const [minute, hour, dayOfMonth, , dayOfWeek] = parts;
 
-  // Map cron day-of-week numbers to systemd abbreviated names
   const dowMap: Record<string, string> = {
     "0": "Sun", "1": "Mon", "2": "Tue", "3": "Wed",
     "4": "Thu", "5": "Fri", "6": "Sat", "7": "Sun",
@@ -73,8 +66,8 @@ export class LinuxPlatform implements PlatformService {
     fs.mkdirSync(UNIT_DIR, { recursive: true });
 
     const palmierBin = process.argv[1] || "palmier";
-    // Save the user's shell PATH so restartDaemon can use it later
-    // (the daemon itself runs under systemd with a limited PATH).
+    // Save the user's shell PATH so restartDaemon can reuse it later — under
+    // systemd the daemon itself runs with a limited PATH.
     const userPath = process.env.PATH || "/usr/local/bin:/usr/bin:/bin";
     fs.mkdirSync(path.dirname(PATH_FILE), { recursive: true });
     fs.writeFileSync(PATH_FILE, userPath, "utf-8");
@@ -110,7 +103,7 @@ WantedBy=default.target
       console.error("You may need to start it manually: systemctl --user enable --now palmier.service");
     }
 
-    // Enable lingering so service runs without active login session
+    // Lingering lets the service run without an active login session.
     try {
       execSync(`loginctl enable-linger ${process.env.USER || ""}`, { stdio: "inherit" });
       console.log("Login lingering enabled.");
@@ -127,11 +120,9 @@ WantedBy=default.target
       execSync("systemctl --user disable palmier.service 2>/dev/null", { stdio: "pipe" });
     } catch { /* service may not exist */ }
 
-    // Remove daemon service file
     const servicePath = path.join(UNIT_DIR, "palmier.service");
     try { fs.unlinkSync(servicePath); } catch { /* ignore */ }
 
-    // Remove all task timers and services
     try {
       const files = fs.readdirSync(UNIT_DIR).filter((f) => f.startsWith("palmier-task-"));
       for (const f of files) {
@@ -148,8 +139,8 @@ WantedBy=default.target
   }
 
   async restartDaemon(): Promise<void> {
-    // If called from a user's terminal, save the current PATH for future use.
-    // If called from the daemon (auto-update), read the saved PATH instead.
+    // From a TTY, snapshot the current PATH; from the daemon (auto-update),
+    // reuse whatever was last saved.
     if (process.stdin.isTTY) {
       fs.mkdirSync(path.dirname(PATH_FILE), { recursive: true });
       fs.writeFileSync(PATH_FILE, process.env.PATH || "", "utf-8");
@@ -196,7 +187,6 @@ Environment=PATH=${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}
     fs.writeFileSync(path.join(UNIT_DIR, serviceName), serviceContent, "utf-8");
     daemonReload();
 
-    // Only create and enable a timer if the schedule exists and is enabled
     if (!task.frontmatter.schedule_enabled) return;
     const scheduleType = task.frontmatter.schedule_type;
     const scheduleValues = task.frontmatter.schedule_values;
@@ -260,7 +250,6 @@ WantedBy=timers.target
   }
 
   isTaskRunning(taskId: string): boolean {
-    // Check systemd first (for scheduled/on-demand runs)
     const serviceName = getServiceName(taskId);
     try {
       const out = execSync(
@@ -271,7 +260,7 @@ WantedBy=timers.target
       if (state === "active" || state === "activating") return true;
     } catch { /* service may not exist */ }
 
-    // Fall back to PID check (for follow-up runs spawned directly)
+    // Follow-up runs are spawned directly, so check PID too.
     try {
       const taskDir = getTaskDir(loadConfig().projectRoot, taskId);
       const status = readTaskStatus(taskDir);

package/src/platform/macos.ts

@@ -0,0 +1,310 @@
+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 type { PlatformService } from "./platform.js";
+import type { HostConfig, ParsedTask } from "../types.js";
+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(): string {
+  return path.join(AGENT_DIR, `${DAEMON_LABEL}.plist`);
+}
+
+function taskLabel(taskId: string): string {
+  return `${TASK_LABEL_PREFIX}${taskId}`;
+}
+
+function taskPlistPath(taskId: string): string {
+  return path.join(AGENT_DIR, `${taskLabel(taskId)}.plist`);
+}
+
+function guiDomain(): string {
+  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: string): Record<string, number> {
+  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: Record<string, number> = {};
+
+  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: string): Record<string, number> {
+  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: string): string {
+  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: unknown, indent: string): string {
+  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 as Record<string, unknown>);
+    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: Record<string, unknown>): string {
+  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: string[], opts: { ignoreFailure?: boolean } = {}): void {
+  try {
+    execSync(`launchctl ${args.join(" ")}`, { stdio: "pipe", encoding: "utf-8" });
+  } catch (err: unknown) {
+    if (opts.ignoreFailure) return;
+    const e = err as { stderr?: string };
+    console.error(`launchctl ${args[0]} failed: ${e.stderr || err}`);
+  }
+}
+
+export class MacOsPlatform implements PlatformService {
+  installDaemon(config: HostConfig): void {
+    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(): void {
+    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(): Promise<void> {
+    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: HostConfig, task: ParsedTask): void {
+    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: Record<string, unknown> = {
+      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: Record<string, number>[] = [];
+      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: string): void {
+    const domain = guiDomain();
+    runLaunchctl(["bootout", `${domain}/${taskLabel(taskId)}`], { ignoreFailure: true });
+    try { fs.unlinkSync(taskPlistPath(taskId)); } catch { /* ignore */ }
+  }
+
+  async startTask(taskId: string): Promise<void> {
+    await execAsync(`launchctl kickstart ${guiDomain()}/${taskLabel(taskId)}`);
+  }
+
+  async stopTask(taskId: string): Promise<void> {
+    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: string): boolean {
+    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(): Record<string, string> {
+    return {};
+  }
+}

package/src/platform/platform.ts

@@ -1,9 +1,6 @@
 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;