palmier 0.7.8 → 0.8.0

package/README.md

@@ -8,7 +8,7 @@
 
 You have AI agents on your machine. But you have to sit at your desk to use them. Palmier lets you dispatch, schedule, and monitor them from any device, anywhere.
 
-It runs on your machine as a background daemon and connects to a mobile-friendly PWA, so you can create tasks, approve permissions, and check results without being at your computer.
+It runs on your machine as a background daemon and connects to a mobile-friendly PWA, so you can start one-off sessions, schedule recurring tasks, approve permissions, and check results without being at your computer.
 > **Important:** By using Palmier, you agree to the [Terms of Service](https://www.palmier.me/terms) and [Privacy Policy](https://www.palmier.me/privacy). See the [Disclaimer](#disclaimer) section below.
 
 ## Quick Start

package/dist/commands/run.js

@@ -209,6 +209,15 @@ export async function runCommand(taskId) {
             await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, runId);
             console.log(`Task ${taskId} completed (command-triggered).`);
         }
+        else if (task.frontmatter.schedule_type === "on_new_notification"
+            || task.frontmatter.schedule_type === "on_new_sms") {
+            // Event-triggered mode (driven by NATS pub/sub of device notifications/SMS)
+            const result = await runEventTriggeredMode(ctx);
+            const outcome = resolveOutcome(taskDir, result.outcome);
+            appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
+            await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, runId);
+            console.log(`Task ${taskId} completed (event-triggered).`);
+        }
         else {
             // Standard execution — add user prompt as first message
             await appendAndNotify(ctx, {
@@ -380,6 +389,52 @@ async function runCommandTriggeredMode(ctx) {
     }
     return { outcome: "finished", endTime };
 }
+/**
+ * Event-triggered execution mode.
+ *
+ * Drains the daemon-owned per-task event queue via the local /task-event/pop
+ * HTTP endpoint, invoking the agent once per event with the payload spliced
+ * into the user prompt. The run process itself holds no NATS subscription;
+ * the daemon handles that and atomically clears the active flag when we see
+ * an empty pop, so it can fire up a fresh run on the next incoming event.
+ */
+async function runEventTriggeredMode(ctx) {
+    const scheduleType = ctx.task.frontmatter.schedule_type;
+    const label = scheduleType === "on_new_notification" ? "notification" : "SMS";
+    const port = ctx.config.httpPort ?? 7256;
+    const popUrl = `http://localhost:${port}/task-event/pop?taskId=${encodeURIComponent(ctx.taskId)}`;
+    console.log(`[event-triggered] Draining ${label} queue`);
+    appendRunMessage(ctx.taskDir, ctx.runId, { role: "status", time: Date.now(), content: "", type: "monitoring" });
+    await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
+    let eventsProcessed = 0;
+    try {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const res = await fetch(popUrl, { method: "POST" });
+            if (!res.ok)
+                throw new Error(`pop-event failed: ${res.status} ${res.statusText}`);
+            const body = await res.json();
+            if (body.empty || !body.event)
+                break;
+            eventsProcessed++;
+            console.log(`[event-triggered] Processing ${label} #${eventsProcessed}`);
+            const perEventPrompt = `${ctx.task.frontmatter.user_prompt}\n\nProcess this new ${label}:\n${body.event}`;
+            const perEventTask = {
+                frontmatter: { ...ctx.task.frontmatter, user_prompt: perEventPrompt },
+            };
+            await invokeAgentWithRetries(ctx, perEventTask);
+            appendRunMessage(ctx.taskDir, ctx.runId, { role: "status", time: Date.now(), content: "", type: "monitoring" });
+            await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
+        }
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        appendRunMessage(ctx.taskDir, ctx.runId, { role: "status", time: Date.now(), content: errorMsg, type: "error" });
+        await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
+        return { outcome: "failed", endTime: Date.now() };
+    }
+    return { outcome: "finished", endTime: Date.now() };
+}
 async function publishTaskEvent(nc, config, taskDir, taskId, eventType, taskName, runId) {
     writeTaskStatus(taskDir, {
         running_state: eventType,

package/dist/commands/serve.js

@@ -14,6 +14,7 @@ import { CONFIG_DIR } from "../config.js";
 import { StringCodec } from "nats";
 import { addNotification } from "../notification-store.js";
 import { addSmsMessage } from "../sms-store.js";
+import { enqueueEvent } from "../event-queues.js";
 const POLL_INTERVAL_MS = 30_000;
 const DAEMON_PID_FILE = path.join(CONFIG_DIR, "daemon.pid");
 /**
@@ -119,28 +120,47 @@ export async function serveCommand() {
         startNatsTransport(config, handleRpc, nc);
         // Subscribe to device notifications and SMS from Android
         const sc = StringCodec();
+        // Dispatch a raw event payload to every task whose schedule matches.
+        function dispatchDeviceEvent(scheduleType, payload) {
+            for (const task of listTasks(config.projectRoot)) {
+                if (task.frontmatter.schedule_type !== scheduleType)
+                    continue;
+                if (!task.frontmatter.schedule_enabled)
+                    continue;
+                const { shouldStart } = enqueueEvent(task.frontmatter.id, payload);
+                if (shouldStart) {
+                    platform.startTask(task.frontmatter.id).catch((err) => {
+                        console.error(`[event-trigger] Failed to start ${task.frontmatter.id}:`, err);
+                    });
+                }
+            }
+        }
         const notifSub = nc.subscribe(`host.${config.hostId}.device.notifications`);
         (async () => {
             for await (const msg of notifSub) {
+                const raw = sc.decode(msg.data);
                 try {
-                    const data = JSON.parse(sc.decode(msg.data));
+                    const data = JSON.parse(raw);
                     addNotification({ ...data, receivedAt: Date.now() });
                 }
                 catch (err) {
                     console.error("[nats] Failed to parse device notification:", err);
                 }
+                dispatchDeviceEvent("on_new_notification", raw);
             }
         })();
         const smsSub = nc.subscribe(`host.${config.hostId}.device.sms`);
         (async () => {
             for await (const msg of smsSub) {
+                const raw = sc.decode(msg.data);
                 try {
-                    const data = JSON.parse(sc.decode(msg.data));
+                    const data = JSON.parse(raw);
                     addSmsMessage({ ...data, receivedAt: Date.now() });
                 }
                 catch (err) {
                     console.error("[nats] Failed to parse device SMS:", err);
                 }
+                dispatchDeviceEvent("on_new_sms", raw);
             }
         })();
     }

package/dist/event-queues.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Per-task in-memory event queues for event-triggered schedules
+ * (schedule_type: "on_new_notification" | "on_new_sms").
+ *
+ * The daemon owns the NATS subscription and populates these queues; the
+ * `palmier run` process drains them via the localhost /task-event/pop HTTP
+ * endpoint. `activeRuns` tracks whether a run process is currently draining,
+ * so we don't race a fresh startTask with a teardown-phase run.
+ *
+ * Lifecycle invariants:
+ *   - activeRuns is cleared atomically inside popEvent when the queue is
+ *     drained. At that point the calling run has already finished its last
+ *     agent invocation and is only tearing down.
+ *   - enqueueEvent returns shouldStart=true only if the task transitioned
+ *     from idle (no active run) to active — callers must then startTask.
+ */
+/**
+ * Queue a raw (JSON-string) event payload for a task. Returns whether the
+ * caller should now start the run process.
+ */
+export declare function enqueueEvent(taskId: string, payload: string): {
+    shouldStart: boolean;
+};
+/**
+ * Pop the oldest queued event for a task. Returns `{ event }` when one is
+ * available (keeps the task marked active), or `{ empty: true }` after
+ * clearing the active flag atomically.
+ */
+export declare function popEvent(taskId: string): {
+    event: string;
+} | {
+    empty: true;
+};
+/** Remove any state for a task (called from task.delete). */
+export declare function clearTaskQueue(taskId: string): void;
+//# sourceMappingURL=event-queues.d.ts.map

package/dist/event-queues.js

@@ -0,0 +1,53 @@
+/**
+ * Per-task in-memory event queues for event-triggered schedules
+ * (schedule_type: "on_new_notification" | "on_new_sms").
+ *
+ * The daemon owns the NATS subscription and populates these queues; the
+ * `palmier run` process drains them via the localhost /task-event/pop HTTP
+ * endpoint. `activeRuns` tracks whether a run process is currently draining,
+ * so we don't race a fresh startTask with a teardown-phase run.
+ *
+ * Lifecycle invariants:
+ *   - activeRuns is cleared atomically inside popEvent when the queue is
+ *     drained. At that point the calling run has already finished its last
+ *     agent invocation and is only tearing down.
+ *   - enqueueEvent returns shouldStart=true only if the task transitioned
+ *     from idle (no active run) to active — callers must then startTask.
+ */
+const MAX_QUEUE_SIZE = 100;
+const queues = new Map();
+const activeRuns = new Set();
+/**
+ * Queue a raw (JSON-string) event payload for a task. Returns whether the
+ * caller should now start the run process.
+ */
+export function enqueueEvent(taskId, payload) {
+    const queue = queues.get(taskId) ?? [];
+    if (queue.length >= MAX_QUEUE_SIZE)
+        queue.shift();
+    queue.push(payload);
+    queues.set(taskId, queue);
+    if (activeRuns.has(taskId))
+        return { shouldStart: false };
+    activeRuns.add(taskId);
+    return { shouldStart: true };
+}
+/**
+ * Pop the oldest queued event for a task. Returns `{ event }` when one is
+ * available (keeps the task marked active), or `{ empty: true }` after
+ * clearing the active flag atomically.
+ */
+export function popEvent(taskId) {
+    const queue = queues.get(taskId);
+    if (queue && queue.length > 0) {
+        return { event: queue.shift() };
+    }
+    activeRuns.delete(taskId);
+    return { empty: true };
+}
+/** Remove any state for a task (called from task.delete). */
+export function clearTaskQueue(taskId) {
+    queues.delete(taskId);
+    activeRuns.delete(taskId);
+}
+//# sourceMappingURL=event-queues.js.map

package/dist/mcp-tools.d.ts

@@ -32,6 +32,8 @@ export interface ResourceDefinition {
     restPath: string;
     /** Return the current resource content. */
     read: () => unknown;
+    /** Register a listener for content changes. Returns an unsubscribe function. */
+    subscribe: (listener: () => void) => () => void;
 }
 export declare const agentResources: ResourceDefinition[];
 export declare const agentResourceMap: Map<string, ResourceDefinition>;

package/dist/mcp-tools.js

@@ -1,8 +1,8 @@
 import { StringCodec } from "nats";
 import { registerPending } from "./pending-requests.js";
 import { getCapabilityDevice } from "./device-capabilities.js";
-import { getNotifications } from "./notification-store.js";
-import { getSmsMessages } from "./sms-store.js";
+import { getNotifications, onNotificationsChanged } from "./notification-store.js";
+import { getSmsMessages, onSmsChanged } from "./sms-store.js";
 export class ToolError extends Error {
     statusCode;
     constructor(message, statusCode = 500) {
@@ -651,6 +651,7 @@ const deviceNotificationsResource = {
     mimeType: "application/json",
     restPath: "/notifications",
     read: getNotifications,
+    subscribe: onNotificationsChanged,
 };
 const deviceSmsResource = {
     uri: "sms-messages://device",
@@ -662,6 +663,7 @@ const deviceSmsResource = {
     mimeType: "application/json",
     restPath: "/sms-messages",
     read: getSmsMessages,
+    subscribe: onSmsChanged,
 };
 export const agentResources = [deviceNotificationsResource, deviceSmsResource];
 export const agentResourceMap = new Map(agentResources.map((r) => [r.uri, r]));

package/dist/platform/linux.js

@@ -181,17 +181,20 @@ 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 triggers exist and are enabled
-        if (!task.frontmatter.triggers_enabled)
+        // 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;
+        if (!scheduleType || !scheduleValues?.length)
             return;
-        const triggers = task.frontmatter.triggers || [];
         const onCalendarLines = [];
-        for (const trigger of triggers) {
-            if (trigger.type === "cron") {
-                onCalendarLines.push(`OnCalendar=${cronToOnCalendar(trigger.value)}`);
+        for (const value of scheduleValues) {
+            if (scheduleType === "crons") {
+                onCalendarLines.push(`OnCalendar=${cronToOnCalendar(value)}`);
             }
-            else if (trigger.type === "once") {
-                onCalendarLines.push(`OnActiveSec=${trigger.value}`);
+            else if (scheduleType === "specific_times") {
+                onCalendarLines.push(`OnActiveSec=${value}`);
             }
         }
         if (onCalendarLines.length > 0) {

package/dist/platform/windows.d.ts

@@ -1,18 +1,17 @@
 import type { PlatformService } from "./platform.js";
 import type { HostConfig, ParsedTask } from "../types.js";
 /**
- * Convert a cron expression or "once" trigger to Task Scheduler XML trigger elements.
+ * Convert a single schedule value to a Task Scheduler XML trigger element.
  *
- * Only these cron patterns (produced by the PWA UI) are handled:
+ * `specific_times` values are ISO datetime strings like "2026-03-28T09:00".
+ *
+ * `crons` values are cron expressions. Only these patterns (produced by the PWA UI) are handled:
  *   hourly:  "0 * * * *"
  *   daily:   "MM HH * * *"
  *   weekly:  "MM HH * * D"
  *   monthly: "MM HH D * *"
  */
-export declare function triggerToXml(trigger: {
-    type: string;
-    value: string;
-}): string;
+export declare function scheduleValueToXml(scheduleType: "crons" | "specific_times", value: string): string;
 /**
  * Build a complete Task Scheduler XML definition.
  */

package/dist/platform/windows.js

@@ -7,22 +7,23 @@ const TASK_PREFIX = "\\Palmier\\PalmierTask-";
 const DAEMON_TASK_NAME = "PalmierDaemon";
 const DOW_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
 /**
- * Convert a cron expression or "once" trigger to Task Scheduler XML trigger elements.
+ * Convert a single schedule value to a Task Scheduler XML trigger element.
  *
- * Only these cron patterns (produced by the PWA UI) are handled:
+ * `specific_times` values are ISO datetime strings like "2026-03-28T09:00".
+ *
+ * `crons` values are cron expressions. Only these patterns (produced by the PWA UI) are handled:
  *   hourly:  "0 * * * *"
  *   daily:   "MM HH * * *"
  *   weekly:  "MM HH * * D"
  *   monthly: "MM HH D * *"
  */
-export function triggerToXml(trigger) {
-    if (trigger.type === "once") {
-        // ISO datetime "2026-03-28T09:00"
-        return `<TimeTrigger><StartBoundary>${trigger.value}:00</StartBoundary></TimeTrigger>`;
+export function scheduleValueToXml(scheduleType, value) {
+    if (scheduleType === "specific_times") {
+        return `<TimeTrigger><StartBoundary>${value}:00</StartBoundary></TimeTrigger>`;
     }
-    const parts = trigger.value.trim().split(/\s+/);
+    const parts = value.trim().split(/\s+/);
     if (parts.length !== 5)
-        throw new Error(`Invalid cron expression: ${trigger.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
@@ -176,15 +177,20 @@ export class WindowsPlatform {
         const tn = schtasksTaskName(taskId);
         const script = process.argv[1] || "palmier";
         const tr = `"${process.execPath}" "${script}" run ${taskId}`;
-        // Build trigger XML elements
+        // 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.
         const triggerElements = [];
-        if (task.frontmatter.triggers_enabled) {
-            for (const trigger of task.frontmatter.triggers ?? []) {
+        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) {
+            for (const value of scheduleValues) {
                 try {
-                    triggerElements.push(triggerToXml(trigger));
+                    triggerElements.push(scheduleValueToXml(scheduleType, value));
                 }
                 catch (err) {
-                    console.error(`Invalid trigger: ${err}`);
+                    console.error(`Invalid schedule value: ${err}`);
                 }
             }
         }