palmier 0.8.3 → 0.8.6

package/README.md

@@ -29,12 +29,12 @@ It runs on your machine as a background daemon and connects to a mobile-friendly
 ### Prerequisites
 
 - **Node.js 24+**
-- **Linux with systemd** or **Windows 10/11** (macOS coming soon)
+- **Linux with systemd**, **macOS 13+**, or **Windows 10/11**
 - At least one supported agent CLI
 
 ## How It Works
 
-Palmier runs as a background daemon (systemd on Linux, Task Scheduler on Windows). It invokes your agent CLIs directly, schedules tasks via native OS timers, and exposes an API that the PWA connects to — either directly over HTTP or remotely through a relay server. Agents can interact with the user's mobile device during execution — requesting input, sending push notifications and full-screen alarms, reading SMS/notifications, managing contacts and calendar, and more.
+Palmier runs as a background daemon (systemd on Linux, launchd on macOS, Task Scheduler on Windows). It invokes your agent CLIs directly, schedules tasks via native OS timers, and exposes an API that the PWA connects to — either directly over HTTP or remotely through a relay server. Agents can interact with the user's mobile device during execution — requesting input, sending push notifications and full-screen alarms, reading SMS/notifications, managing contacts and calendar, and more.
 
 ### MCP Server
 
@@ -148,11 +148,13 @@ The wizard:
 - Configures access modes (HTTP port, LAN access)
 - Shows a summary (including any existing scheduled tasks to recover) and asks for confirmation
 - Registers with the Palmier server, saves configuration to `~/.config/palmier/host.json`
-- Installs a background daemon (systemd user service on Linux, Task Scheduler on Windows)
+- Installs a background daemon (systemd user service on Linux, LaunchAgent on macOS, Task Scheduler on Windows)
 - Auto-enters pair mode to connect your first device
 
 The daemon automatically recovers existing tasks by reinstalling their system timers on startup.
 
+> **macOS note:** Palmier installs as a user-level LaunchAgent, so it runs without `sudo`. LaunchAgents only run while the user is logged into the GUI session — after a reboot, scheduled tasks stay dormant until you log in at least once. Enable auto-login in System Settings → Users & Groups if you need unattended operation across reboots.
+
 Agents are re-detected on every daemon start. Run `palmier restart` after installing or removing a CLI.
 
 ## CLI Reference
@@ -190,7 +192,7 @@ To fully remove Palmier from a machine:
 
 4. **(Optional) Remove configuration and task data:**
 
-   **Linux:**
+   **Linux / macOS:**
    ```bash
    rm -rf ~/.config/palmier
    rm -rf ~/palmier   # or wherever your Palmier root directory is

package/dist/commands/pair.js

@@ -1,4 +1,5 @@
 import * as http from "node:http";
+import * as os from "node:os";
 import { StringCodec } from "nats";
 import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
@@ -16,6 +17,7 @@ function buildPairResponse(config, label) {
     return {
         hostId: config.hostId,
         clientToken: client.token,
+        hostName: os.hostname(),
     };
 }
 function httpPairRegister(port, code) {

package/dist/commands/serve.js

@@ -15,7 +15,6 @@ import { StringCodec } from "nats";
 import { addNotification } from "../notification-store.js";
 import { addSmsMessage } from "../sms-store.js";
 import { enqueueEvent } from "../event-queues.js";
-import { recordApp } from "../app-registry.js";
 const POLL_INTERVAL_MS = 30_000;
 const DAEMON_PID_FILE = path.join(CONFIG_DIR, "daemon.pid");
 /**
@@ -144,10 +143,7 @@ export async function serveCommand() {
                 let parsed;
                 try {
                     parsed = JSON.parse(raw);
-                    const data = parsed;
                     addNotification({ ...parsed, receivedAt: Date.now() });
-                    if (data.packageName && data.appName)
-                        recordApp(data.packageName, data.appName);
                 }
                 catch (err) {
                     console.error("[nats] Failed to parse device notification:", err);

package/dist/platform/index.js

@@ -1,13 +1,17 @@
 import { LinuxPlatform } from "./linux.js";
 import { WindowsPlatform } from "./windows.js";
+import { MacOsPlatform } from "./macos.js";
 /** Windows needs an explicit shell for execSync to resolve .cmd shims. */
 export const SHELL = process.platform === "win32" ? "cmd.exe" : undefined;
 let _instance;
 export function getPlatform() {
     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/dist/platform/macos.d.ts

@@ -0,0 +1,32 @@
+import type { PlatformService } from "./platform.js";
+import type { HostConfig, ParsedTask } from "../types.js";
+/**
+ * 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 declare function cronToCalendarInterval(cron: string): Record<string, number>;
+/**
+ * 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 declare function specificTimeToCalendarInterval(iso: string): Record<string, number>;
+export declare function buildPlist(dict: Record<string, unknown>): string;
+export declare class MacOsPlatform implements PlatformService {
+    installDaemon(config: HostConfig): void;
+    uninstallDaemon(): void;
+    restartDaemon(): Promise<void>;
+    installTaskTimer(config: HostConfig, task: ParsedTask): void;
+    removeTaskTimer(taskId: string): void;
+    startTask(taskId: string): Promise<void>;
+    stopTask(taskId: string): Promise<void>;
+    isTaskRunning(taskId: string): boolean;
+    getGuiEnv(): Record<string, string>;
+}
+//# sourceMappingURL=macos.d.ts.map

package/dist/platform/macos.js

@@ -0,0 +1,298 @@
+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 taskLogPath(taskId) {
+    return path.join(CONFIG_DIR, `task-${taskId}.log`);
+}
+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";
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        const logPath = taskLogPath(taskId);
+        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" },
+            StandardOutPath: logPath,
+            StandardErrorPath: logPath,
+        };
+        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 */ }
+        try {
+            fs.unlinkSync(taskLogPath(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