palmier 0.8.3 → 0.8.4

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/rpc-handler.ts

@@ -12,7 +12,6 @@ import { getAgent } from "./agents/agent.js";
 import { validateClient } from "./client-store.js";
 import { publishHostEvent } from "./events.js";
 import { getCapabilityDevice, setCapabilityDevice, clearCapabilityDevice, type DeviceCapability } from "./device-capabilities.js";
-import { listApps } from "./app-registry.js";
 import { currentVersion, performUpdate } from "./update-checker.js";
 import { parseReportFiles, parseTaskOutcome, stripPalmierMarkers } from "./commands/run.js";
 import { clearTaskQueue } from "./event-queues.js";
@@ -662,10 +661,6 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         return { ok: true };
       }
 
-      case "device.notifications.apps": {
-        return { apps: listApps() };
-      }
-
       default:
         return { error: `Unknown method: ${request.method}` };
     }

package/src/transports/http-transport.ts

@@ -365,6 +365,7 @@ export async function startHttpTransport(
           hostId: config.hostId,
           clientToken: client.token,
           directUrl: `http://${ip}:${port}`,
+          hostName: os.hostname(),
         };
 
         clearTimeout(pending.timer);

package/test/macos-plist.test.ts

@@ -0,0 +1,112 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import {
+  cronToCalendarInterval,
+  specificTimeToCalendarInterval,
+  buildPlist,
+} from "../src/platform/macos.js";
+
+describe("cronToCalendarInterval", () => {
+  it("converts hourly cron", () => {
+    assert.deepEqual(cronToCalendarInterval("0 * * * *"), { Minute: 0 });
+  });
+
+  it("converts daily cron", () => {
+    assert.deepEqual(cronToCalendarInterval("30 9 * * *"), { Minute: 30, Hour: 9 });
+  });
+
+  it("converts weekly Monday cron", () => {
+    assert.deepEqual(cronToCalendarInterval("0 10 * * 1"), { Minute: 0, Hour: 10, Weekday: 1 });
+  });
+
+  it("converts weekly Sunday (day 0)", () => {
+    assert.deepEqual(cronToCalendarInterval("0 8 * * 0"), { Minute: 0, Hour: 8, Weekday: 0 });
+  });
+
+  it("converts weekly Sunday (day 7 -> 0)", () => {
+    assert.deepEqual(cronToCalendarInterval("0 8 * * 7"), { Minute: 0, Hour: 8, Weekday: 0 });
+  });
+
+  it("converts monthly cron", () => {
+    assert.deepEqual(cronToCalendarInterval("0 14 15 * *"), { Minute: 0, Hour: 14, Day: 15 });
+  });
+
+  it("throws on invalid cron expression", () => {
+    assert.throws(() => cronToCalendarInterval("bad"), /Invalid cron/);
+  });
+
+  it("throws on too few fields", () => {
+    assert.throws(() => cronToCalendarInterval("0 * *"), /Invalid cron/);
+  });
+});
+
+describe("specificTimeToCalendarInterval", () => {
+  it("parses an ISO local datetime", () => {
+    assert.deepEqual(
+      specificTimeToCalendarInterval("2026-04-20T09:00"),
+      { Month: 4, Day: 20, Hour: 9, Minute: 0 },
+    );
+  });
+
+  it("parses an ISO datetime with seconds", () => {
+    assert.deepEqual(
+      specificTimeToCalendarInterval("2026-12-31T23:59:30"),
+      { Month: 12, Day: 31, Hour: 23, Minute: 59 },
+    );
+  });
+
+  it("throws on malformed input", () => {
+    assert.throws(() => specificTimeToCalendarInterval("not-a-date"), /Invalid specific_times/);
+  });
+});
+
+describe("buildPlist", () => {
+  it("emits a valid plist envelope with ProgramArguments", () => {
+    const xml = buildPlist({
+      Label: "me.palmier.host",
+      ProgramArguments: ["/usr/local/bin/node", "/opt/palmier/dist/index.js", "serve"],
+      RunAtLoad: true,
+    });
+
+    assert.ok(xml.startsWith(`<?xml version="1.0" encoding="UTF-8"?>`), "xml header");
+    assert.ok(xml.includes(`<!DOCTYPE plist PUBLIC`), "doctype");
+    assert.ok(xml.includes(`<plist version="1.0">`), "plist tag");
+    assert.ok(xml.includes(`<key>Label</key>`), "label key");
+    assert.ok(xml.includes(`<string>me.palmier.host</string>`), "label value");
+    assert.ok(xml.includes(`<key>ProgramArguments</key>`), "program args key");
+    assert.ok(xml.includes(`<string>/usr/local/bin/node</string>`), "program args first");
+    assert.ok(xml.includes(`<true/>`), "boolean");
+  });
+
+  it("serializes StartCalendarInterval as an array of dicts", () => {
+    const xml = buildPlist({
+      Label: "me.palmier.task.abc",
+      StartCalendarInterval: [
+        { Minute: 0, Hour: 9 },
+        { Minute: 30, Hour: 14, Weekday: 1 },
+      ],
+    });
+
+    assert.ok(xml.includes(`<key>StartCalendarInterval</key>`));
+    assert.ok(xml.includes(`<array>`));
+    assert.ok(xml.includes(`<key>Minute</key>`));
+    assert.ok(xml.includes(`<integer>0</integer>`));
+    assert.ok(xml.includes(`<integer>9</integer>`));
+    assert.ok(xml.includes(`<key>Weekday</key>`));
+    assert.ok(xml.includes(`<integer>1</integer>`));
+  });
+
+  it("nests dicts (EnvironmentVariables.PATH)", () => {
+    const xml = buildPlist({
+      EnvironmentVariables: { PATH: "/usr/local/bin:/usr/bin:/bin" },
+    });
+    assert.ok(xml.includes(`<key>EnvironmentVariables</key>`));
+    assert.ok(xml.includes(`<key>PATH</key>`));
+    assert.ok(xml.includes(`<string>/usr/local/bin:/usr/bin:/bin</string>`));
+  });
+
+  it("escapes XML special characters in strings", () => {
+    const xml = buildPlist({ Label: "a & b <c>" });
+    assert.ok(xml.includes(`<string>a &amp; b &lt;c&gt;</string>`));
+  });
+});

package/dist/app-registry.d.ts

@@ -1,10 +0,0 @@
-/** Persistent cache of packageName → appName pairs seen via device notifications. */
-export interface AppInfo {
-    packageName: string;
-    appName: string;
-}
-/** Writes only on change so we track the latest label if an app renames itself. */
-export declare function recordApp(packageName: string, appName: string): void;
-export declare function listApps(): AppInfo[];
-export declare function getAppName(packageName: string): string | undefined;
-//# sourceMappingURL=app-registry.d.ts.map

package/dist/app-registry.js

@@ -1,44 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { CONFIG_DIR } from "./config.js";
-const REGISTRY_FILE = path.join(CONFIG_DIR, "app-registry.json");
-let cache = null;
-function load() {
-    if (cache)
-        return cache;
-    try {
-        if (fs.existsSync(REGISTRY_FILE)) {
-            cache = JSON.parse(fs.readFileSync(REGISTRY_FILE, "utf-8"));
-            return cache;
-        }
-    }
-    catch {
-        // Corrupt file — start fresh rather than fail notifications.
-    }
-    cache = {};
-    return cache;
-}
-function persist(map) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
-    fs.writeFileSync(REGISTRY_FILE, JSON.stringify(map, null, 2), "utf-8");
-}
-/** Writes only on change so we track the latest label if an app renames itself. */
-export function recordApp(packageName, appName) {
-    if (!packageName || !appName)
-        return;
-    const map = load();
-    if (map[packageName] === appName)
-        return;
-    map[packageName] = appName;
-    persist(map);
-}
-export function listApps() {
-    const map = load();
-    return Object.entries(map)
-        .map(([packageName, appName]) => ({ packageName, appName }))
-        .sort((a, b) => a.appName.localeCompare(b.appName));
-}
-export function getAppName(packageName) {
-    return load()[packageName];
-}
-//# sourceMappingURL=app-registry.js.map