palmier 0.8.1 → 0.8.3

package/palmier-server/pwa/src/components/SwipeToDeleteRow.tsx

@@ -0,0 +1,160 @@
+import { useEffect, useRef, useState, type ReactNode, type PointerEvent } from "react";
+
+interface SwipeToDeleteRowProps {
+  /** Unique id used to coordinate "at most one row revealed" with the parent. */
+  id: string;
+  /** The id of the currently-revealed row (or null). Set to this row's id to reveal it. */
+  revealedId: string | null;
+  setRevealedId(id: string | null): void;
+  onDelete(): void;
+  onClick?(): void;
+  children: ReactNode;
+  /** Label for the action button (default "Delete"). */
+  actionLabel?: string;
+}
+
+const REVEAL_WIDTH = 88;              // px width of the action button
+const OPEN_THRESHOLD = REVEAL_WIDTH / 2;
+const AXIS_LOCK_THRESHOLD = 6;        // px of horizontal travel before we claim the gesture
+
+/**
+ * Wraps a row with swipe-left to reveal a destructive action button.
+ * Tap the button to confirm, tap elsewhere to dismiss the reveal.
+ *
+ * Uses pointer events so the same code works for touch and mouse. A short
+ * axis-lock period at the start of a drag decides whether the user is
+ * scrolling vertically (let it through) or swiping horizontally (capture).
+ */
+export default function SwipeToDeleteRow({
+  id,
+  revealedId,
+  setRevealedId,
+  onDelete,
+  onClick,
+  children,
+  actionLabel = "Delete",
+}: SwipeToDeleteRowProps) {
+  const revealed = revealedId === id;
+  const [dragOffset, setDragOffset] = useState(0);
+  const [dragging, setDragging] = useState(false);
+
+  const startX = useRef(0);
+  const startY = useRef(0);
+  const axis = useRef<"x" | "y" | null>(null);
+  const baseOffset = useRef(0);       // translateX when the gesture started
+  const movedEnough = useRef(false);  // whether we should suppress the click that follows
+  const rowRef = useRef<HTMLDivElement>(null);
+
+  // Reset local drag offset whenever parent closes this row.
+  useEffect(() => {
+    if (!revealed) setDragOffset(0);
+  }, [revealed]);
+
+  // Close when the user taps elsewhere in the document.
+  useEffect(() => {
+    if (!revealed) return;
+    function onDocPointerDown(e: Event) {
+      if (rowRef.current?.contains(e.target as Node)) return;
+      setRevealedId(null);
+    }
+    document.addEventListener("pointerdown", onDocPointerDown);
+    return () => document.removeEventListener("pointerdown", onDocPointerDown);
+  }, [revealed, setRevealedId]);
+
+  function handlePointerDown(e: PointerEvent<HTMLDivElement>) {
+    // Ignore non-primary buttons (right-click etc.) so we don't steal them.
+    if (e.button !== undefined && e.button !== 0) return;
+    startX.current = e.clientX;
+    startY.current = e.clientY;
+    axis.current = null;
+    baseOffset.current = revealed ? -REVEAL_WIDTH : 0;
+    movedEnough.current = false;
+  }
+
+  function handlePointerMove(e: PointerEvent<HTMLDivElement>) {
+    if (e.pointerType === "mouse" && e.buttons === 0) return;   // not dragging
+    const dx = e.clientX - startX.current;
+    const dy = e.clientY - startY.current;
+
+    if (axis.current === null) {
+      if (Math.abs(dx) < AXIS_LOCK_THRESHOLD && Math.abs(dy) < AXIS_LOCK_THRESHOLD) return;
+      axis.current = Math.abs(dx) > Math.abs(dy) ? "x" : "y";
+      if (axis.current === "x") {
+        try { (e.currentTarget as Element).setPointerCapture(e.pointerId); } catch { /* unsupported */ }
+      }
+    }
+    if (axis.current !== "x") return;
+
+    movedEnough.current = true;
+    if (!dragging) setDragging(true);
+    // Clamp: can swipe left to reveal fully, a bit of rubber-band on the right.
+    let next = baseOffset.current + dx;
+    if (next > 0) next = next / 4;
+    if (next < -REVEAL_WIDTH) next = -REVEAL_WIDTH + (next + REVEAL_WIDTH) / 4;
+    setDragOffset(next);
+  }
+
+  function handlePointerUp() {
+    if (axis.current !== "x") {
+      setDragging(false);
+      return;
+    }
+    axis.current = null;
+    setDragging(false);
+
+    const finalOffset = dragOffset;
+    const openNow = finalOffset <= -OPEN_THRESHOLD;
+    if (openNow) {
+      setDragOffset(-REVEAL_WIDTH);
+      setRevealedId(id);
+    } else {
+      setDragOffset(0);
+      if (revealed) setRevealedId(null);
+    }
+  }
+
+  function handleClickCapture(e: React.MouseEvent) {
+    // If the gesture translated the row, treat it as a swipe — not a click.
+    // Also absorb the click that re-hides a revealed row.
+    if (movedEnough.current) {
+      movedEnough.current = false;
+      e.stopPropagation();
+      e.preventDefault();
+      return;
+    }
+    if (revealed) {
+      e.stopPropagation();
+      e.preventDefault();
+      setRevealedId(null);
+    }
+  }
+
+  const currentOffset = dragOffset !== 0 ? dragOffset : (revealed ? -REVEAL_WIDTH : 0);
+
+  return (
+    <div ref={rowRef} className="swipe-row">
+      <button
+        type="button"
+        className="swipe-row-action"
+        style={{ width: REVEAL_WIDTH }}
+        onClick={(e) => { e.stopPropagation(); onDelete(); }}
+        tabIndex={revealed ? 0 : -1}
+        aria-hidden={!revealed}
+      >
+        {actionLabel}
+      </button>
+      <div
+        className={`swipe-row-content ${dragging ? "swipe-row-content-dragging" : ""}`}
+        style={{ transform: `translateX(${currentOffset}px)` }}
+        onPointerDown={handlePointerDown}
+        onPointerMove={handlePointerMove}
+        onPointerUp={handlePointerUp}
+        onPointerCancel={handlePointerUp}
+        onClickCapture={handleClickCapture}
+        onClick={onClick}
+      >
+        {children}
+      </div>
+    </div>
+  );
+}

package/palmier-server/pwa/src/components/TaskForm.tsx

@@ -1,7 +1,9 @@
 import { useEffect, useState, useCallback, useRef } from "react";
+import { Capacitor } from "@capacitor/core";
 import { useHostConnection } from "../contexts/HostConnectionContext";
 import PlanDialog from "./PlanDialog";
 import { useBackClose } from "../hooks/useBackClose";
+import { Device } from "../native/Device";
 import type { AgentInfo, Task } from "../types";
 
 type ScheduleType = "crons" | "specific_times" | "on_new_notification" | "on_new_sms";
@@ -140,6 +142,71 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
   const [command, setCommand] = useState(initial?.command ?? "");
   const [saving, setSaving] = useState(false);
 
+  // Single optional app filter for on_new_notification tasks. Empty = any app;
+  // non-empty = single packageName filter (stored as a one-entry schedule_values
+  // array on save). Datalist options come from the host-side app registry.
+  // No migration: pre-existing multi-app tasks truncate to the first entry on
+  // first edit.
+  const initialNotificationApp: string = (() => {
+    if (initial?.schedule_type === "on_new_notification" && initial.schedule_values && initial.schedule_values.length > 0) {
+      return initial.schedule_values[0];
+    }
+    return "";
+  })();
+  const [notificationApp, setNotificationApp] = useState<string>(initialNotificationApp);
+  const [knownApps, setKnownApps] = useState<Array<{ packageName: string; appName: string; icon?: string }>>([]);
+  const [appDropdownOpen, setAppDropdownOpen] = useState(false);
+
+  // Merge native launcher enum (complete, native-only) with host registry
+  // (apps already seen — fills the gap on non-native clients). Dedup by
+  // packageName; free-form typing still works if neither knows the package.
+  useEffect(() => {
+    if (scheduleMode !== "on_new_notification") return;
+    let cancelled = false;
+
+    const merged = new Map<string, { packageName: string; appName: string; icon?: string }>();
+    const PALMIER_PACKAGE = "com.palmier.app";
+    const flush = () => { if (!cancelled) setKnownApps(Array.from(merged.values()).sort((a, b) => (a.appName || a.packageName).localeCompare(b.appName || b.packageName))); };
+
+    if (Capacitor.isNativePlatform() && Device) {
+      Device.getInstalledApps()
+        .then(({ apps }) => {
+          if (cancelled) return;
+          for (const a of apps) {
+            if (a.packageName === PALMIER_PACKAGE) continue;
+            merged.set(a.packageName, { packageName: a.packageName, appName: a.appName, icon: a.icon });
+          }
+          flush();
+        })
+        .catch(() => {});
+    }
+
+    request<{ apps?: Array<{ packageName: string; appName: string }> }>("device.notifications.apps")
+      .then((res) => {
+        if (cancelled || !res.apps) return;
+        for (const a of res.apps) {
+          if (a.packageName === PALMIER_PACKAGE) continue;
+          if (!merged.has(a.packageName)) merged.set(a.packageName, a);
+        }
+        flush();
+      })
+      .catch(() => {});
+
+    return () => { cancelled = true; };
+  }, [scheduleMode]);
+
+  // Sender filter for on_new_sms tasks. Empty string = any sender; non-empty =
+  // whitelist a single sender (stored as a single-entry schedule_values array
+  // on save). Matching is normalized on the host — users don't need to worry
+  // about exact phone-number formatting.
+  const initialSmsSender: string = (() => {
+    if (initial?.schedule_type === "on_new_sms" && initial.schedule_values && initial.schedule_values.length > 0) {
+      return initial.schedule_values[0];
+    }
+    return "";
+  })();
+  const [smsSender, setSmsSender] = useState<string>(initialSmsSender);
+
   const commandInputRef = useRef<HTMLInputElement>(null);
 
   const modeIsScheduled = isScheduleSlot(scheduleMode);
@@ -169,7 +236,9 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
       JSON.stringify(collectScheduleValues()) !== JSON.stringify(initial?.schedule_values ?? [])
       || modeToScheduleType(scheduleMode as ScheduleSlot) !== (initial?.schedule_type ?? undefined)
     ))
-    || (modeIsEvent && scheduleMode !== initial?.schedule_type);
+    || (modeIsEvent && scheduleMode !== initial?.schedule_type)
+    || (scheduleMode === "on_new_notification" && notificationApp.trim() !== initialNotificationApp.trim())
+    || (scheduleMode === "on_new_sms" && smsSender.trim() !== initialSmsSender.trim());
 
   const hasInvalidTrigger = modeIsScheduled && triggerRows.some((r) =>
     r.schedule === "specific_times" && (!r.onceDate || new Date(`${r.onceDate}T${r.onceTime}`) <= new Date())
@@ -209,6 +278,12 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
     } else {
       setCommand("");
     }
+    if (next !== "on_new_notification") {
+      setNotificationApp(initialNotificationApp);
+    }
+    if (next !== "on_new_sms") {
+      setSmsSender(initialSmsSender);
+    }
   }
 
   function collectScheduleValues(): string[] {
@@ -229,7 +304,13 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
     setSaving(true);
     setError(null);
     try {
-      const scheduleValues = modeIsScheduled ? collectScheduleValues() : [];
+      const scheduleValues = modeIsScheduled
+        ? collectScheduleValues()
+        : scheduleMode === "on_new_notification" && notificationApp.trim()
+          ? [notificationApp.trim()]
+          : scheduleMode === "on_new_sms" && smsSender.trim()
+            ? [smsSender.trim()]
+            : [];
       const scheduleType: ScheduleType | null = modeIsScheduled
         ? modeToScheduleType(scheduleMode as ScheduleSlot)
         : modeIsEvent
@@ -376,6 +457,75 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
                   : "Runs each time a new SMS arrives on the paired Android device."}
                 {" "}The triggering payload is spliced into your task prompt — reference it as &ldquo;the new {scheduleMode === "on_new_notification" ? "notification" : "SMS"}&rdquo;.
               </p>
+              {scheduleMode === "on_new_notification" && (() => {
+                const q = notificationApp.trim().toLowerCase();
+                const filtered = q
+                  ? knownApps.filter((a) => a.packageName.toLowerCase().includes(q) || a.appName.toLowerCase().includes(q))
+                  : knownApps;
+                return (
+                  <>
+                    <div className="app-combobox">
+                      <input
+                        className="form-input"
+                        type="text"
+                        value={notificationApp}
+                        onChange={(e) => { setNotificationApp(e.target.value); setAppDropdownOpen(true); }}
+                        onFocus={() => setAppDropdownOpen(true)}
+                        onBlur={() => setAppDropdownOpen(false)}
+                        placeholder={Capacitor.isNativePlatform() ? "App (optional)" : "App (optional, e.g. com.google.android.gm)"}
+                        disabled={saving}
+                      />
+                      {appDropdownOpen && filtered.length > 0 && (
+                        <ul className="app-combobox-list">
+                          {filtered.map((a) => (
+                            <li
+                              key={a.packageName}
+                              className="app-combobox-row"
+                              // onMouseDown instead of onClick so the input's blur doesn't close
+                              // the dropdown before the selection registers.
+                              onMouseDown={(e) => {
+                                e.preventDefault();
+                                setNotificationApp(a.packageName);
+                                setAppDropdownOpen(false);
+                              }}
+                            >
+                              {a.icon
+                                ? <img src={a.icon} alt="" className="app-combobox-icon" />
+                                : <div className="app-combobox-icon app-combobox-icon-placeholder" />}
+                              <div className="app-combobox-labels">
+                                <div className="app-combobox-name">{a.appName || a.packageName}</div>
+                                {a.appName && <div className="app-combobox-pkg">{a.packageName}</div>}
+                              </div>
+                            </li>
+                          ))}
+                        </ul>
+                      )}
+                    </div>
+                    <p className="command-help-text app-filter-help">
+                      {notificationApp.trim()
+                        ? `Only notifications from ${notificationApp.trim()} will trigger this task.`
+                        : "Every notification from your device triggers this task."}
+                    </p>
+                  </>
+                );
+              })()}
+              {scheduleMode === "on_new_sms" && (
+                <>
+                  <input
+                    className="form-input"
+                    type="text"
+                    value={smsSender}
+                    onChange={(e) => setSmsSender(e.target.value)}
+                    placeholder="From (optional), e.g. +1 555-1234)"
+                    disabled={saving}
+                  />
+                  <p className="command-help-text app-filter-help">
+                    {smsSender.trim()
+                      ? `Only SMS from ${smsSender.trim()} will trigger this task. Formatting (spaces, dashes, parens) is ignored.`
+                      : "Every SMS that arrives on your device triggers this task."}
+                  </p>
+                </>
+              )}
             </div>
           )}
 

package/palmier-server/pwa/src/constants.ts

@@ -1,2 +1,2 @@
 /** Bump when a breaking host change is made. */
-export const MIN_HOST_VERSION = "0.8.0";
+export const MIN_HOST_VERSION = "0.8.3";

package/palmier-server/pwa/src/native/Device.ts

@@ -2,12 +2,14 @@ import { Capacitor, registerPlugin, type PluginListenerHandle } from "@capacitor
 
 export type PermissionType =
   | "location"
-  | "sms"
+  | "smsRead"
+  | "smsSend"
   | "contacts"
   | "calendar"
   | "notificationListener"
   | "dnd"
-  | "fullScreenIntent";
+  | "fullScreenIntent"
+  | "postNotifications";
 
 export interface PermissionResult {
   granted: boolean;
@@ -23,6 +25,13 @@ export interface DeepLinkEvent {
   path: string;
 }
 
+export interface InstalledApp {
+  packageName: string;
+  appName: string;
+  /** data:image/png;base64 URL, 96x96. May be absent if the icon couldn't be rendered. */
+  icon?: string;
+}
+
 interface DevicePlugin {
   getFcmToken(): Promise<{ token: string }>;
   /** Returns the set of PermissionType strings this native build understands. */
@@ -36,6 +45,15 @@ interface DevicePlugin {
    * ahead of the installed APK.
    */
   setEnabledCapabilities(opts: { capabilities: string[] }): Promise<void>;
+  /** Returns user-visible (launcher) apps on the device, with 96x96 PNG icons. */
+  getInstalledApps(): Promise<{ apps: InstalledApp[] }>;
+  /**
+   * Returns whether the device has at least one app that can handle a mailto:
+   * intent. Used to gate the Sending Email capability — silent PackageManager
+   * lookup, no side effects. `supported: false` on older APKs that don't expose
+   * this method; treat as "cannot enable" rather than as a hard error.
+   */
+  hasEmailClient(): Promise<{ available: boolean; supported: boolean }>;
   addListener(
     event: "deepLink",
     handler: (ev: DeepLinkEvent) => void

package/palmier-server/pwa/src/pages/Dashboard.tsx

@@ -282,7 +282,7 @@ export default function Dashboard() {
     } catch {
       // Expected: connection drops during daemon restart
     }
-    setTimeout(() => window.location.reload(), 10000);
+    setTimeout(() => window.location.reload(), 15000);
   }
 
   const hasHosts = pairedHosts.length > 0;
@@ -294,10 +294,15 @@ export default function Dashboard() {
       {isDesktop && <HostMenu daemonVersion={daemonVersion} capabilityTokens={capabilityTokens} activeClientToken={activeClientToken} request={request} onCapabilityTokensChange={setCapabilityTokens} />}
 
       <div className="dashboard-content">
-        <div className="tab-bar">
-          {!isDesktop && <HostMenu daemonVersion={daemonVersion} capabilityTokens={capabilityTokens} activeClientToken={activeClientToken} request={request} onCapabilityTokensChange={setCapabilityTokens} />}
-          <TabBar />
-        </div>
+        <header className="app-header">
+          <div className="app-title-bar">
+            {!isDesktop && <HostMenu daemonVersion={daemonVersion} capabilityTokens={capabilityTokens} activeClientToken={activeClientToken} request={request} onCapabilityTokensChange={setCapabilityTokens} />}
+            <h1 className="app-title">Palmier</h1>
+          </div>
+          <div className="tab-bar">
+            <TabBar />
+          </div>
+        </header>
 
         <main className="dashboard-main">
         {unauthorized ? (
@@ -369,7 +374,7 @@ export default function Dashboard() {
           </>
         ) : (
           <div className="empty-state">
-            <p>{hasHosts ? "Connecting to host..." : "No hosts paired yet."}</p>
+            <p>{hasHosts ? "Connecting to host..." : "No host computer paired yet."}</p>
             {!hasHosts && (
               <button
                 className="btn btn-primary"

package/palmier-server/server/src/index.ts

@@ -392,12 +392,12 @@ async function main(): Promise<void> {
     }
   })();
 
-  // Subscribe to alert requests from hosts
+  // Subscribe to alarm requests from hosts
   (async () => {
     try {
       const conn = await getNatsConnection();
-      const sub = conn.subscribe("host.*.fcm.alert");
-      console.log("Listening for FCM alert requests");
+      const sub = conn.subscribe("host.*.fcm.alarm");
+      console.log("Listening for FCM alarm requests");
 
       for await (const msg of sub) {
         try {
@@ -418,14 +418,14 @@ async function main(): Promise<void> {
           }
 
           const fcmPayload: Record<string, string> = {
-            type: "send-alert",
+            type: "send-alarm",
             requestId: data.requestId,
             hostId: data.hostId,
           };
           if (data.title) fcmPayload.title = data.title;
           if (data.description) fcmPayload.description = data.description;
 
-          console.log(`[FCM] Sending alert request for host ${data.hostId}`);
+          console.log(`[FCM] Sending alarm request for host ${data.hostId}`);
           if (data.fcmToken) {
             await sendFcmToDevice(data.fcmToken, fcmPayload);
           } else {
@@ -436,14 +436,14 @@ async function main(): Promise<void> {
             msg.respond(sc.encode(JSON.stringify({ ok: true })));
           }
         } catch (err) {
-          console.error("[FCM] Error handling alert request:", err);
+          console.error("[FCM] Error handling alarm request:", err);
           if (msg.reply) {
             msg.respond(sc.encode(JSON.stringify({ error: String(err) })));
           }
         }
       }
     } catch (err) {
-      console.error("Failed to subscribe to FCM alert requests:", err);
+      console.error("Failed to subscribe to FCM alarm requests:", err);
     }
   })();
 

package/palmier-server/server/src/routes/device.ts

@@ -125,8 +125,8 @@ router.post("/sms-response", async (req: Request, res: Response) => {
   }
 });
 
-// POST /api/device/alert-response - Receive alert response from Android, relay to host via NATS
-router.post("/alert-response", async (req: Request, res: Response) => {
+// POST /api/device/alarm-response - Receive alarm response from Android, relay to host via NATS
+router.post("/alarm-response", async (req: Request, res: Response) => {
   try {
     const { requestId, hostId, result } = req.body;
 
@@ -138,13 +138,13 @@ router.post("/alert-response", async (req: Request, res: Response) => {
     const conn = await getNatsConnection();
     const sc = StringCodec();
     conn.publish(
-      `host.${hostId}.alert.${requestId}`,
+      `host.${hostId}.alarm.${requestId}`,
       sc.encode(JSON.stringify(result)),
     );
 
     res.json({ ok: true });
   } catch (err) {
-    console.error("Device alert response relay error:", err);
+    console.error("Device alarm response relay error:", err);
     res.status(500).json({ error: "Internal server error" });
   }
 });

package/palmier-server/spec.md

@@ -12,18 +12,18 @@ The host supports **Linux** (systemd) and **Windows** (Task Scheduler for both d
 
 ### 1.2 Components
 
-* **Host Binary (Node.js):** Runs persistently on the user's host machine as a NATS + HTTP RPC handler. Manages file system operations (task CRUD), OS-level scheduling (systemd), and task generation. Provides a CLI with commands: `palmier init` (provisioning), `palmier pair` (generate pairing code for device pairing), `palmier clients` (manage client tokens), `palmier run <task-id>` (executes a task via the configured agent tool), `palmier uninstall` (stop daemon and remove all scheduled tasks), and `palmier serve` (persistent RPC handler, default command). The `serve` process always starts a local HTTP server (bound to `127.0.0.1` by default, or `0.0.0.0` if LAN mode is enabled) alongside the NATS transport. Exposes a localhost-only MCP server at `/mcp` (streamable HTTP transport) with tools: `notify`, `request-input`, `request-confirmation`, `device-geolocation`, `read-contacts`, `create-contact`, `read-calendar`, `create-calendar-event`, `send-sms-message`, `set-alarm`, `read-battery`, `set-ringer-mode`; and resources: `notifications://device` (device notifications), `sms-messages://device` (SMS messages). Tools and resources are auto-generated as REST endpoints from shared registries (`ToolDefinition[]`, `ResourceDefinition[]`) — zero duplication. Tool REST endpoints are POST with `taskId` query param; resource REST endpoints are GET. `/request-permission` remains a separate endpoint (not part of the MCP registries). MCP resources support subscriptions — clients call `resources/subscribe` and the server holds the POST response open as an SSE stream, pushing `notifications/resources/updated` notifications when the resource data changes. MCP sessions track agent names from `initialize` clientInfo for logging and UI display. `palmier run` is a short-lived process invoked by systemd. Task execution is abstracted through an `AgentTool` interface (`src/agents/agent.ts`) so different AI CLI tools can be supported — each agent implements `getPromptCommandLine()`, `getTaskRunCommandLine()`, and `init()`. The task's `agent` field (e.g., `"claude"`) selects which agent is used.
+* **Host Binary (Node.js):** Runs persistently on the user's host machine as a NATS + HTTP RPC handler. Manages file system operations (task CRUD), OS-level scheduling (systemd), and task generation. Provides a CLI with commands: `palmier init` (provisioning), `palmier pair` (generate pairing code for device pairing), `palmier clients` (manage client tokens), `palmier run <task-id>` (executes a task via the configured agent tool), `palmier uninstall` (stop daemon and remove all scheduled tasks), and `palmier serve` (persistent RPC handler, default command). The `serve` process always starts a local HTTP server (bound to `127.0.0.1` by default, or `0.0.0.0` if LAN mode is enabled) alongside the NATS transport. Exposes a localhost-only MCP server at `/mcp` (streamable HTTP transport) with tools: `notify`, `request-input`, `request-confirmation`, `device-geolocation`, `read-contacts`, `create-contact`, `read-calendar`, `create-calendar-event`, `send-sms-message`, `send-alarm`, `read-battery`, `set-ringer-mode`; and resources: `notifications://device` (device notifications), `sms-messages://device` (SMS messages). Tools and resources are auto-generated as REST endpoints from shared registries (`ToolDefinition[]`, `ResourceDefinition[]`) — zero duplication. Tool REST endpoints are POST with `taskId` query param; resource REST endpoints are GET. `/request-permission` remains a separate endpoint (not part of the MCP registries). MCP resources support subscriptions — clients call `resources/subscribe` and the server holds the POST response open as an SSE stream, pushing `notifications/resources/updated` notifications when the resource data changes. MCP sessions track agent names from `initialize` clientInfo for logging and UI display. `palmier run` is a short-lived process invoked by systemd. Task execution is abstracted through an `AgentTool` interface (`src/agents/agent.ts`) so different AI CLI tools can be supported — each agent implements `getPromptCommandLine()`, `getTaskRunCommandLine()`, and `init()`. The task's `agent` field (e.g., `"claude"`) selects which agent is used.
 
 * **Web Server (Node.js):** Serves the PWA assets (React) via `app.palmier.me` (Cloudflare proxied), manages Web Push VAPID keys, and provides host registration. Uses **PostgreSQL** for persistent storage (host registrations, push subscriptions, FCM tokens). Connects to NATS via TCP to subscribe to `host-event.>` for sending push notifications (confirmations, dismissals, completion/failure). For `POST /api/push/respond` (confirmation responses via push notification action buttons), the Web Server forwards the response to the host via the `task.user_input` NATS RPC. Subscribes to `host.*.push.send` NATS subjects to relay push notification requests from the host CLI. Subscribes to `host.*.fcm.geolocation` to relay device geolocation requests via FCM. Subscribes to `host.*.fcm.contacts`, `host.*.fcm.calendar`, `host.*.fcm.sms`, `host.*.fcm.alarm`, `host.*.fcm.battery`, and `host.*.fcm.ringer` to relay device capability requests via FCM. Provides HTTP endpoints for Android to post responses back (`/api/device/contacts-response`, `/api/device/calendar-response`, `/api/device/sms-response`, `/api/device/alarm-response`, `/api/device/battery-response`, `/api/device/ringer-response`). Co-located with the NATS server on the same machine.
 
 * **Android App (Capacitor):** Native Android wrapper for the PWA. Provides FCM push messaging for receiving data messages in the background, `FusedLocationProviderClient` for GPS access, `NotificationListenerService` for capturing device notifications, `BroadcastReceiver` for incoming SMS, and handlers for contacts, calendar, alarms, battery, and ringer mode. All device tools work while the app is in the background via FCM data messages. When a request arrives via FCM, the appropriate handler executes the action and POSTs the result back to the Web Server. Device capabilities and their permissions:
   - **Notifications**: `NotificationListenerService` — requires notification listener access (system settings toggle)
-  - **SMS receive**: `SmsBroadcastReceiver` — requires `RECEIVE_SMS` + `SEND_SMS` runtime permissions
-  - **SMS send**: `SmsHandler` — requires `SEND_SMS` runtime permission (shared with SMS receive toggle)
+  - **SMS Read**: `SmsBroadcastReceiver` — requires `RECEIVE_SMS` runtime permission
+  - **SMS Send**: `SmsHandler` — requires `SEND_SMS` runtime permission
   - **Contacts**: `ContactsHandler` — requires `READ_CONTACTS` + `WRITE_CONTACTS` runtime permissions
   - **Calendar**: `CalendarHandler` — requires `READ_CALENDAR` + `WRITE_CALENDAR` runtime permissions
   - **Geolocation**: `GeolocationForegroundService` — requires `ACCESS_FINE_LOCATION` runtime permission
-  - **Alarm**: `AlarmHandler` — requires `SET_ALARM` (normal permission, auto-granted)
+  - **Alarm**: `AlarmHandler` + `AlarmActivity` — triggers a full-screen alarm popup with looping ringtone; requires `USE_FULL_SCREEN_INTENT` (Android 14+ requires user grant in settings)
   - **Battery**: `BatteryHandler` — no permission required
   - **Ringer mode**: `RingerHandler` — requires Do Not Disturb access (system settings toggle)
 
@@ -49,6 +49,37 @@ The project is split across two repositories:
 
 * **`palmier`**: The host binary. A standalone Node.js CLI that runs on the user's machine.
 * **`palmier-server`**: Contains both the Web Server (`server/`) and the PWA (`pwa/`, built with Vite + React). Uses **pnpm** for package management with a pnpm workspace.
+* **`palmier-android`**: Capacitor-based Android wrapper that loads the PWA from `app.palmier.me` in a WebView and exposes native device capabilities via a custom plugin.
+
+### 1.5 Android Implementation Details
+
+The Android app is a thin native shell over the remotely-hosted PWA. The design decisions below are non-obvious enough that changing them silently would break assumptions the rest of the system makes.
+
+**Remote-first WebView.** `capacitor.config.json` sets `server.url` to `https://app.palmier.me`; the WebView fetches the PWA from the cloud on every launch. This means PWA updates ship instantly with no APK rebuild, and release builds run `npx cap sync` only (no PWA build step). Consequences:
+
+- **Server mode only.** LAN and Local modes are browser-only. The WebView blocks cleartext `http://<host-ip>:<port>` requests as mixed content, so LAN users must open the PWA from Chrome/Safari directly.
+- **Offline fallback.** When `app.palmier.me` is unreachable, the WebView loads `www/offline.html` (configured via `server.errorPath`), which auto-reloads when connectivity returns.
+- **PWA ships ahead of the APK.** The PWA may reference permission types or native methods that the installed APK doesn't implement yet. `Device.getSupportedPermissions()` returns the set the APK understands; `checkPermission` / `requestPermission` resolve with `{ granted: false, supported: false }` for unknown types rather than throwing. The PWA uses this to hide toggles it can't fulfill.
+
+**Unified `Device` Capacitor plugin.** A single plugin (`DevicePlugin.kt`) exposes the entire native surface — FCM token, permission gate, capability whitelist, installed-app enumeration, email-client availability, deep-link events. This replaces seven per-capability permission plugins. Methods: `getFcmToken`, `getSupportedPermissions`, `checkPermission({type})`, `requestPermission({type})`, `setEnabledCapabilities({capabilities})`, `getInstalledApps`, `hasEmailClient`, `addListener("deepLink", ...)`. Permission types: `location`, `smsRead`, `smsSend`, `contacts`, `calendar`, `notificationListener`, `dnd`, `fullScreenIntent`, `postNotifications`.
+
+**Capability kill-switch (`CapabilityState`).** Local whitelist persisted as a JSON-array string under `enabledCapabilities` in `CapacitorStorage` SharedPreferences, written only by `DevicePlugin.setEnabledCapabilities` from the PWA's derived state. Native receivers (`SmsBroadcastReceiver`, `DeviceNotificationListenerService`) and all FCM handlers consult this before acting — a second line of defense beyond the server-side capability token. If the user disables a capability in the drawer, the native side refuses to relay events or respond to requests even if the server still asks.
+
+**FCM token flow.** The PWA reads the current token on demand via `Device.getFcmToken()`; no cached copy in SharedPreferences. `PalmierFirebaseMessagingService.onNewToken` still re-registers with the relay server itself (using the stored `hostId`) because background token refreshes can fire while the PWA isn't running.
+
+**Deep links.** FCM notification taps pass a relative path (e.g. `/runs/:taskId/:runId`) via an `Intent` extra named `deepLink`. `MainActivity.handleDeepLink` forwards the path to `DevicePlugin.emitDeepLink`, which emits a `deepLink` event the PWA's router handles client-side. If the plugin isn't ready yet (intent arrives before `onPostCreate`), `MainActivity` buffers the path and flushes in `onPostCreate`. No external `intent-filter` is registered — Android 11+ `<queries>` entries are declared so `hasEmailClient` and installed-app enumeration work without `QUERY_ALL_PACKAGES`.
+
+**Notification listener filtering and debounce.** `DeviceNotificationListenerService` drops notifications from (a) Palmier's own `palmier_tasks` channel to avoid feedback loops and (b) the default SMS app (SMS is captured separately via `SmsBroadcastReceiver`, which arrives before the SMS app's notification). Empty-title+body notifications are skipped. A 2-second debounce per `packageName:title` key dedupes rapid updates; the debounce map is LRU-capped at 200 entries.
+
+**SMS capture.** Multi-part SMS arrives as multiple PDUs in a single `SMS_RECEIVED` broadcast. `SmsBroadcastReceiver` groups parts by `displayOriginatingAddress` and concatenates bodies before relaying, otherwise long messages would arrive as fragments.
+
+**Alarm capability.** `AlarmHandler` posts a `CATEGORY_ALARM` notification on the DND-bypassing `palmier_alarms` channel with a full-screen intent targeting `AlarmActivity`. `AlarmActivity` extends `AppCompatActivity`, shows over the lock screen (`setShowWhenLocked`/`setTurnScreenOn` on O_MR1+, legacy window flags below), and plays the default alarm ringtone on the alarm audio stream via `RingtoneManager`. Requires `USE_FULL_SCREEN_INTENT`; Android 14+ requires the user to grant it in per-app settings.
+
+**Email capability.** FCM `send-email` messages post a "Pending email" notification whose tap launches `EmailActivity` — a translucent `Activity` (not `AppCompatActivity`, so `Theme.Translucent` applies) that builds a `mailto:` URI and starts the email app with `ACTION_SENDTO`. The activity auto-finishes on result, returning the user to the previous screen. `hasEmailClient` gates the toggle in the PWA to avoid enabling a capability no installed app can fulfill.
+
+**Location capability.** `GeolocationForegroundService` briefly starts as a foreground service (`FOREGROUND_SERVICE_TYPE_LOCATION` on U+) and uses `FusedLocationProviderClient.getCurrentLocation(PRIORITY_HIGH_ACCURACY)` for a single fix before stopping itself. Requires both `ACCESS_FINE_LOCATION` and `ACCESS_BACKGROUND_LOCATION` on Q+; the plugin requests them sequentially.
+
+**Releases.** GitHub Actions builds a signed APK and creates a release when a `v*` tag is pushed. The workflow runs `npm ci && npx cap sync` — no PWA build step since the WebView loads remotely.
 
 ## 2. Host Provisioning & Device Pairing
 
@@ -227,8 +258,8 @@ requires_confirmation: true
 
 * `"crons"` — `schedule_values` holds cron expressions.
 * `"specific_times"` — `schedule_values` holds local datetime strings (e.g. `"2026-04-20T09:00"`).
-* `"on_new_notification"` — fires once per new Android notification relayed over NATS. No `schedule_values`.
-* `"on_new_sms"` — fires once per new SMS relayed over NATS. No `schedule_values`.
+* `"on_new_notification"` — fires once per new Android notification relayed over NATS. Optional `schedule_values` holds a single-entry packageName filter; empty/unset matches any app.
+* `"on_new_sms"` — fires once per new SMS relayed over NATS. Optional `schedule_values` holds a single-entry sender filter (phone number or alphanumeric shortcode); compared after normalizing away spaces, dashes, parens, plus sign, and case. Empty/unset matches any sender.
 
 For `crons` / `specific_times` the schedule is installed as an OS timer (systemd / Task Scheduler). For the `on_new_*` types the `palmier run` process subscribes directly to the corresponding NATS subject (`host.<hostId>.device.notifications` or `...device.sms`), drains events through a bounded FIFO queue, and invokes the agent once per event with the event payload spliced into the user prompt (mirroring command-triggered mode). These event-driven tasks are not started on save — they launch via `task.run` (the PWA auto-runs them on create, matching command-triggered UX).
 
@@ -313,7 +344,7 @@ Dashboard owns the always-on NATS event subscription and renders pending `confir
 
 4. For updates: if the user changes the `user_prompt` or `agent`, the name is regenerated. If neither changed, the existing name is preserved. Existing tasks with granted permissions show a clickable "Granted Permissions" link to view them.
 
-5. PWA sends `task.create` (or `task.update` with `id`) with the task fields as the message body. The `id` field is **not sent on create** — the host generates a UUID. `schedule_type` and `schedule_values` are omitted when the task has no schedule; `schedule_values` is also omitted for the `on_new_notification` / `on_new_sms` types.
+5. PWA sends `task.create` (or `task.update` with `id`) with the task fields as the message body. The `id` field is **not sent on create** — the host generates a UUID. `schedule_type` and `schedule_values` are omitted when the task has no schedule. For `on_new_notification` / `on_new_sms` types, `schedule_values` is sent only when a filter is configured (single packageName for notifications, single sender for SMS).
 
 6. Host creates/updates the `tasks/<task-id>/TASK.md` file and returns the **full flat task object** (all frontmatter fields at the top level). The PWA uses this response directly to update the UI.
 

package/src/agents/agent.ts

@@ -26,10 +26,6 @@ export interface CommandLine {
   env?: Record<string, string>;
 }
 
-/**
- * Interface that each agent tool must implement.
- * Abstracts how plans are generated and tasks are executed across different AI agents.
- */
 export interface AgentTool {
   /** Return the command and args for a short, non-interactive prompt (e.g. generating a task name). */
   getPromptCommandLine(prompt: string): CommandLine;

package/src/agents/claude.ts

@@ -24,7 +24,7 @@ export class ClaudeAgent implements AgentTool {
       }
     }
 
-    if (followupPrompt) {args.push("-c");} // continue mode for followups
+    if (followupPrompt) {args.push("-c");}
     return { command: "claude", args, stdin: prompt };
   }
 

package/src/agents/codex.ts

@@ -23,8 +23,8 @@ export class CodexAgent implements AgentTool {
         args.push(`apps.${p.name}.default_tools_approval_mode="approve"`);
       }
     }
-    if (followupPrompt) {args.push("resume", "--last");} // continue mode for followups
-    args.push("-"); // read prompt from stdin
+    if (followupPrompt) {args.push("resume", "--last");}
+    args.push("-");
 
     return { command: "codex", args, stdin: prompt };
   }