palmier 0.8.1 → 0.8.4

package/dist/mcp-tools.js

@@ -400,9 +400,9 @@ const sendSmsTool = {
     async handler(args, ctx) {
         if (!ctx.nc)
             throw new ToolError("Not connected to server (NATS unavailable)", 503);
-        const device = getCapabilityDevice("sms");
+        const device = getCapabilityDevice("sms-send");
         if (!device)
-            throw new ToolError("No device has SMS access enabled", 400);
+            throw new ToolError("No device has SMS Send enabled", 400);
         const { to, body } = args;
         if (!to || !body)
             throw new ToolError("to and body are required", 400);
@@ -433,10 +433,10 @@ const sendSmsTool = {
         return result;
     },
 };
-const sendAlertTool = {
-    name: "send-alert",
+const sendAlarmTool = {
+    name: "send-alarm",
     description: [
-        "Send an alert to the user's mobile device with an alarm sound and full-screen popup.",
+        "Trigger an alarm on the user's mobile device with an alarm sound and full-screen popup.",
         "Use this to urgently get the user's attention. The device will play an alarm sound and show a full-screen dialog even on the lock screen.",
         "Blocks until the device responds (up to 30 seconds).",
         'Response: `{"ok": true}` on success, or `{"error": "..."}` on failure.',
@@ -444,17 +444,17 @@ const sendAlertTool = {
     inputSchema: {
         type: "object",
         properties: {
-            title: { type: "string", description: "Alert title" },
-            description: { type: "string", description: "Alert description/details" },
+            title: { type: "string", description: "Alarm title" },
+            description: { type: "string", description: "Alarm description/details" },
         },
         required: ["title"],
     },
     async handler(args, ctx) {
         if (!ctx.nc)
             throw new ToolError("Not connected to server (NATS unavailable)", 503);
-        const device = getCapabilityDevice("alert");
+        const device = getCapabilityDevice("alarm");
         if (!device)
-            throw new ToolError("No device has alert access enabled", 400);
+            throw new ToolError("No device has alarm access enabled", 400);
         const { title, description } = args;
         if (!title)
             throw new ToolError("title is required", 400);
@@ -465,12 +465,12 @@ const sendAlertTool = {
         };
         if (description)
             payload.description = description;
-        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.alert`, sc.encode(JSON.stringify(payload)), { timeout: 5_000 });
+        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.alarm`, sc.encode(JSON.stringify(payload)), { timeout: 5_000 });
         const ack = JSON.parse(sc.decode(ackReply.data));
         if (ack.error)
             throw new ToolError(ack.error, 502);
         const responsePromise = new Promise((resolve, reject) => {
-            const sub = ctx.nc.subscribe(`host.${ctx.config.hostId}.alert.${ctx.sessionId}`, { max: 1 });
+            const sub = ctx.nc.subscribe(`host.${ctx.config.hostId}.alarm.${ctx.sessionId}`, { max: 1 });
             const timer = setTimeout(() => {
                 sub.unsubscribe();
                 reject(new ToolError("Device did not respond within 30 seconds", 504));
@@ -639,7 +639,7 @@ const sendEmailTool = {
         return result;
     },
 };
-export const agentTools = [notifyTool, requestInputTool, requestConfirmationTool, deviceGeolocationTool, readContactsTool, createContactTool, readCalendarTool, createCalendarEventTool, sendSmsTool, sendEmailTool, sendAlertTool, readBatteryTool, setRingerModeTool];
+export const agentTools = [notifyTool, requestInputTool, requestConfirmationTool, deviceGeolocationTool, readContactsTool, createContactTool, readCalendarTool, createCalendarEventTool, sendSmsTool, sendEmailTool, sendAlarmTool, readBatteryTool, setRingerModeTool];
 export const agentToolMap = new Map(agentTools.map((t) => [t.name, t]));
 const deviceNotificationsResource = {
     uri: "notifications://device",
@@ -667,9 +667,6 @@ const deviceSmsResource = {
 };
 export const agentResources = [deviceNotificationsResource, deviceSmsResource];
 export const agentResourceMap = new Map(agentResources.map((r) => [r.uri, r]));
-/**
- * Generate the HTTP Endpoints markdown section for agent-instructions.md from the tool registry.
- */
 export function generateEndpointDocs(port, taskId, tools = agentTools, resources = agentResources) {
     const baseUrl = `http://localhost:${port}`;
     const lines = [
@@ -680,7 +677,6 @@ export function generateEndpointDocs(port, taskId, tools = agentTools, resources
         const schema = tool.inputSchema;
         const props = schema.properties ?? {};
         const required = new Set(schema.required ?? []);
-        // Build example JSON (body only, no taskId)
         const example = {};
         for (const [key, prop] of Object.entries(props)) {
             if (prop.type === "array")

package/dist/nats-client.d.ts

@@ -1,7 +1,4 @@
 import { type NatsConnection } from "nats";
 import type { HostConfig } from "./types.js";
-/**
- * Connect to NATS using the host config's JWT credentials.
- */
 export declare function connectNats(config: HostConfig): Promise<NatsConnection>;
 //# sourceMappingURL=nats-client.d.ts.map

package/dist/nats-client.js

@@ -1,7 +1,4 @@
 import { connect, jwtAuthenticator } from "nats";
-/**
- * Connect to NATS using the host config's JWT credentials.
- */
 export async function connectNats(config) {
     if (!config.natsJwt || !config.natsNkeySeed) {
         throw new Error("NATS JWT credentials not configured. Re-run palmier init.");
@@ -10,7 +7,7 @@ export async function connectNats(config) {
         servers: config.natsUrl,
         authenticator: jwtAuthenticator(config.natsJwt, new TextEncoder().encode(config.natsNkeySeed)),
     });
-    // Do not log anything as that will pollute stdout for mcp server.
+    // Do not log — it would pollute stdout for the MCP server.
     return nc;
 }
 //# sourceMappingURL=nats-client.js.map

package/dist/pending-requests.d.ts

@@ -17,29 +17,15 @@ export interface PendingRequest {
     meta?: PendingRequestMeta;
 }
 /**
- * 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 declare function registerPending(key: string, type: PendingRequest["type"], params?: PendingRequest["params"], meta?: PendingRequestMeta): Promise<string[]>;
-/**
- * Resolve a pending request with the user's response.
- * Returns true if a pending request was found and resolved.
- */
 export declare function resolvePending(key: string, value: string[]): boolean;
-/**
- * Get the current pending request for a key (if any).
- */
 export declare function getPending(key: string): PendingRequest | undefined;
-/**
- * Remove a pending request without resolving it.
- */
 export declare function removePending(key: string): void;
-/**
- * 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 declare function listPending(): Array<{
     key: string;
     type: PendingRequest["type"];

package/dist/pending-requests.js

@@ -1,9 +1,8 @@
 const pending = new Map();
 /**
- * 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, type, params, meta) {
     if (pending.has(key)) {
@@ -13,10 +12,6 @@ export function registerPending(key, type, params, meta) {
         pending.set(key, { type, resolve, params, meta });
     });
 }
-/**
- * Resolve a pending request with the user's response.
- * Returns true if a pending request was found and resolved.
- */
 export function resolvePending(key, value) {
     const entry = pending.get(key);
     if (!entry)
@@ -25,22 +20,13 @@ export function resolvePending(key, value) {
     entry.resolve(value);
     return true;
 }
-/**
- * Get the current pending request for a key (if any).
- */
 export function getPending(key) {
     return pending.get(key);
 }
-/**
- * Remove a pending request without resolving it.
- */
 export function removePending(key) {
     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() {
     return [...pending.entries()].map(([key, entry]) => ({
         key,

package/dist/platform/index.d.ts

@@ -1,8 +1,5 @@
 import type { PlatformService } from "./platform.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 declare const SHELL: string | undefined;
 export declare function getPlatform(): PlatformService;
 export type { PlatformService } from "./platform.js";

package/dist/platform/index.js

@@ -1,16 +1,17 @@
 import { LinuxPlatform } from "./linux.js";
 import { WindowsPlatform } from "./windows.js";
-/**
- * On Windows, execSync needs an explicit shell so .cmd shims resolve correctly.
- * On Unix, undefined lets Node use the default shell.
- */
+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/linux.d.ts

@@ -1,15 +1,9 @@
 import type { PlatformService } from "./platform.js";
 import type { HostConfig, ParsedTask } from "../types.js";
 /**
- * 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 declare function cronToOnCalendar(cron: string): string;
 export declare class LinuxPlatform implements PlatformService {

package/dist/platform/linux.js

@@ -15,15 +15,9 @@ function getServiceName(taskId) {
     return `palmier-task-${taskId}.service`;
 }
 /**
- * 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) {
     const parts = cron.trim().split(/\s+/);
@@ -31,7 +25,6 @@ export function cronToOnCalendar(cron) {
         throw new Error(`Invalid cron expression (expected 5 fields): ${cron}`);
     }
     const [minute, hour, dayOfMonth, , dayOfWeek] = parts;
-    // Map cron day-of-week numbers to systemd abbreviated names
     const dowMap = {
         "0": "Sun", "1": "Mon", "2": "Tue", "3": "Wed",
         "4": "Thu", "5": "Fri", "6": "Sat", "7": "Sun",
@@ -59,8 +52,8 @@ export class LinuxPlatform {
     installDaemon(config) {
         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");
@@ -93,7 +86,7 @@ WantedBy=default.target
             console.error(`Warning: failed to enable systemd service: ${err}`);
             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.");
@@ -109,13 +102,11 @@ 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) {
@@ -142,8 +133,8 @@ WantedBy=default.target
         console.log("Palmier daemon and tasks uninstalled.");
     }
     async restartDaemon() {
-        // 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");
@@ -181,7 +172,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;
@@ -248,7 +238,6 @@ WantedBy=timers.target
         await execAsync(`systemctl --user stop ${serviceName}`);
     }
     isTaskRunning(taskId) {
-        // Check systemd first (for scheduled/on-demand runs)
         const serviceName = getServiceName(taskId);
         try {
             const out = execSync(`systemctl --user show -p ActiveState --value ${serviceName}`, { encoding: "utf-8" });
@@ -257,7 +246,7 @@ WantedBy=timers.target
                 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/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