palmier 0.8.0 → 0.8.3

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

@@ -1,22 +1,29 @@
 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";
+type ScheduleType = "crons" | "specific_times" | "on_new_notification" | "on_new_sms";
+type EventMode = "on_new_notification" | "on_new_sms";
 
 
 const DAYS_OF_WEEK = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
 
 type ScheduleSlot = "specific_times" | "hourly" | "daily" | "weekly" | "monthly";
-type ScheduleMode = "ondemand" | "command" | ScheduleSlot;
+type ScheduleMode = "ondemand" | "command" | EventMode | ScheduleSlot;
 
 const SCHEDULE_SLOTS: readonly ScheduleMode[] = ["specific_times", "hourly", "daily", "weekly", "monthly"];
 function isScheduleSlot(mode: ScheduleMode): mode is ScheduleSlot {
   return (SCHEDULE_SLOTS as readonly string[]).includes(mode);
 }
 
+function isEventMode(mode: ScheduleMode): mode is EventMode {
+  return mode === "on_new_notification" || mode === "on_new_sms";
+}
+
 interface TriggerRow {
   schedule: ScheduleSlot;
   time: string;
@@ -41,7 +48,7 @@ function cronToRow(cron: string): TriggerRow {
   return { ...newRow("daily"), time };
 }
 
-function valueToRow(scheduleType: ScheduleType, value: string): TriggerRow {
+function valueToRow(scheduleType: "crons" | "specific_times", value: string): TriggerRow {
   if (scheduleType === "specific_times") {
     const [datePart, timePart] = value.split("T");
     return { ...newRow("specific_times"), onceDate: datePart ?? "", onceTime: (timePart ?? "09:00").slice(0, 5) };
@@ -67,15 +74,21 @@ function rowToValue(row: TriggerRow): string | null {
   return rowToCron(row);
 }
 
-function modeToScheduleType(mode: ScheduleSlot): ScheduleType {
-  return mode === "specific_times" ? "specific_times" : "crons";
+function modeToScheduleType(mode: ScheduleSlot | EventMode): ScheduleType {
+  if (mode === "specific_times") return "specific_times";
+  if (mode === "on_new_notification") return "on_new_notification";
+  if (mode === "on_new_sms") return "on_new_sms";
+  return "crons";
 }
 
 function initialScheduleMode(initial?: Task): ScheduleMode {
-  if (initial?.command) return "command";
-  const type = initial?.schedule_type;
-  const first = initial?.schedule_values?.[0];
-  if (!type || !first) return "ondemand";
+  if (!initial) return "daily";
+  if (initial.command) return "command";
+  const type = initial.schedule_type;
+  if (type === "on_new_notification" || type === "on_new_sms") return type;
+  if (type !== "crons" && type !== "specific_times") return "ondemand";
+  const first = initial.schedule_values?.[0];
+  if (!first) return "ondemand";
   return valueToRow(type, first).schedule;
 }
 
@@ -113,22 +126,92 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
     () => {
       const type = initial?.schedule_type;
       const values = initial?.schedule_values;
-      if (!type || !values) return [];
-      return values.map((v) => valueToRow(type, v));
+      if (values && (type === "crons" || type === "specific_times")) {
+        return values.map((v) => valueToRow(type, v));
+      }
+      const mode = initialScheduleMode(initial);
+      return isScheduleSlot(mode) ? [newRow(mode)] : [];
     }
   );
   const [requiresConfirmation, setRequiresConfirmation] = useState(
     initial?.requires_confirmation ?? false
   );
+  const [scheduleEnabled, setScheduleEnabled] = useState(initial?.schedule_enabled ?? true);
   const [yoloMode, setYoloMode] = useState(initial?.yolo_mode ?? false);
   const [foregroundMode, setForegroundMode] = useState(initial?.foreground_mode ?? false);
   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);
   const modeIsCommand = scheduleMode === "command";
+  const modeIsEvent = isEventMode(scheduleMode);
 
   const selectedAgent = agents.find((a) => a.key === agent);
   const agentSupportsYolo = !!selectedAgent?.supportsYolo;
@@ -145,13 +228,17 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
     || agent !== (initial?.agent ?? "")
     || scheduleMode !== initialMode
     || requiresConfirmation !== (initial?.requires_confirmation ?? false)
+    || scheduleEnabled !== (initial?.schedule_enabled ?? true)
     || yoloMode !== (initial?.yolo_mode ?? false)
     || foregroundMode !== (initial?.foreground_mode ?? false)
     || (modeIsCommand && command !== (initial?.command ?? ""))
     || (modeIsScheduled && (
       JSON.stringify(collectScheduleValues()) !== JSON.stringify(initial?.schedule_values ?? [])
       || modeToScheduleType(scheduleMode as ScheduleSlot) !== (initial?.schedule_type ?? undefined)
-    ));
+    ))
+    || (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())
@@ -172,7 +259,7 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
 
   function addRow() {
     if (!isScheduleSlot(scheduleMode)) return;
-    setTriggerRows((prev) => [...prev, newRow(scheduleMode)]);
+    setTriggerRows((prev) => [...prev, prev.length > 0 ? { ...prev[prev.length - 1] } : newRow(scheduleMode)]);
   }
 
   function changeScheduleMode(next: ScheduleMode) {
@@ -191,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[] {
@@ -211,15 +304,25 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
     setSaving(true);
     setError(null);
     try {
-      const scheduleValues = modeIsScheduled ? collectScheduleValues() : [];
-      const hasSchedule = scheduleValues.length > 0;
+      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
+          ? modeToScheduleType(scheduleMode as EventMode)
+          : null;
       const payload: Record<string, unknown> = {
         user_prompt: userPrompt,
         agent,
-        schedule_type: hasSchedule ? modeToScheduleType(scheduleMode as ScheduleSlot) : null,
-        schedule_values: hasSchedule ? scheduleValues : null,
-        schedule_enabled: hasSchedule,
-        requires_confirmation: hasSchedule ? requiresConfirmation : false,
+        schedule_type: scheduleType,
+        schedule_values: scheduleValues.length > 0 ? scheduleValues : null,
+        schedule_enabled: scheduleMode !== "ondemand" && scheduleEnabled,
+        requires_confirmation: modeIsScheduled ? requiresConfirmation : false,
         yolo_mode: yoloMode,
         foreground_mode: foregroundMode,
         command: modeIsCommand ? command : "",
@@ -235,7 +338,9 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
       }
       if (!isEdit) localStorage.setItem("palmier:lastAgent", agent);
 
-      // Reactive on create: save the task, then start it and navigate to the run.
+      // Command-triggered on create: save the task, then start it and navigate
+      // to the run. Event-triggered tasks are started by the daemon in response
+      // to the next NATS event, so we just save.
       if (modeIsCommand && !isEdit) {
         onSaved(result);
         try {
@@ -257,7 +362,7 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
   const saveButtonLabel = (() => {
     if (isEdit) return "Save";
     if (modeIsCommand) return "Run";
-    if (modeIsScheduled) return "Schedule";
+    if ((modeIsScheduled || modeIsEvent) && scheduleEnabled) return "Schedule";
     return "Save";
   })();
 
@@ -325,18 +430,6 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
         </div>
 
         <div className="toggles-group">
-        {hostPlatform === "win32" && (
-          <label className="toggle-label">
-            <input
-              type="checkbox"
-              checked={foregroundMode}
-              onChange={(e) => setForegroundMode(e.target.checked)}
-              disabled={saving}
-            />
-            Run in the foreground (host must login to Windows)
-          </label>
-        )}
-
         <div className="schedule-section">
           <h3 className="schedule-section-title">Schedule</h3>
           <select
@@ -351,9 +444,91 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
             <option value="daily">Daily</option>
             <option value="weekly">Weekly</option>
             <option value="monthly">Monthly</option>
+            <option value="on_new_notification">On New Push Notification</option>
+            <option value="on_new_sms">On New SMS</option>
             <option value="command">Command-triggered</option>
           </select>
 
+          {modeIsEvent && (
+            <div className="schedule-reactive">
+              <p className="command-help-text">
+                {scheduleMode === "on_new_notification"
+                  ? "Runs each time a new notification arrives on the paired Android device."
+                  : "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>
+          )}
+
           {modeIsCommand && (
             <div className="schedule-reactive">
               <p className="command-help-text">
@@ -461,6 +636,17 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
             </>
           )}
 
+          {hostPlatform === "win32" && (
+            <label className="toggle-label">
+              <input
+                type="checkbox"
+                checked={foregroundMode}
+                onChange={(e) => setForegroundMode(e.target.checked)}
+                disabled={saving}
+              />
+              Run in the foreground (host must login to Windows)
+            </label>
+          )}
           {modeIsScheduled && (
             <label className="toggle-label">
               <input
@@ -472,6 +658,17 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
               Confirm before each run
             </label>
           )}
+          {scheduleMode !== "ondemand" && (
+            <label className="toggle-label">
+              <input
+                type="checkbox"
+                checked={scheduleEnabled}
+                onChange={(e) => setScheduleEnabled(e.target.checked)}
+                disabled={saving}
+              />
+              Enabled
+            </label>
+          )}
         </div>
         </div>
 

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

@@ -122,6 +122,11 @@ export default function TasksView({ connected, hostId, request, subscribeEvents,
             </div>
           ))}
         </div>
+      ) : tasks.length === 0 ? (
+        <div className="empty-state">
+          <p className="empty-state-text">No tasks yet</p>
+          <p className="empty-state-hint">Tap the + button to create your first task.</p>
+        </div>
       ) : (
         <div className="task-list">
           {tasks.map((task) => (

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.7.8";
+export const MIN_HOST_VERSION = "0.8.3";

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

@@ -0,0 +1,66 @@
+import { Capacitor, registerPlugin, type PluginListenerHandle } from "@capacitor/core";
+
+export type PermissionType =
+  | "location"
+  | "smsRead"
+  | "smsSend"
+  | "contacts"
+  | "calendar"
+  | "notificationListener"
+  | "dnd"
+  | "fullScreenIntent"
+  | "postNotifications";
+
+export interface PermissionResult {
+  granted: boolean;
+  /**
+   * False when the native build doesn't recognize this permission type — the PWA
+   * is served remotely and may ship ahead of the installed APK. Callers should
+   * treat unsupported types as "cannot enable" rather than as a hard error.
+   */
+  supported: boolean;
+}
+
+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. */
+  getSupportedPermissions(): Promise<{ types: PermissionType[] }>;
+  checkPermission(opts: { type: PermissionType }): Promise<PermissionResult>;
+  requestPermission(opts: { type: PermissionType }): Promise<PermissionResult>;
+  /**
+   * Authoritative list of capabilities the user has enabled on this device.
+   * Native receivers + handlers consult this as a local kill-switch. Unknown
+   * capability names are stored but ignored — safe for PWAs that ship new caps
+   * 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
+  ): Promise<PluginListenerHandle>;
+}
+
+/** Null on web — callers must guard with Capacitor.isNativePlatform(). */
+export const Device = Capacitor.isNativePlatform()
+  ? registerPlugin<DevicePlugin>("Device")
+  : null;

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/pwa/src/pages/PairHost.tsx

@@ -4,6 +4,7 @@ import { connect, jwtAuthenticator, StringCodec } from "nats.ws";
 import { Capacitor } from "@capacitor/core";
 import { Preferences } from "@capacitor/preferences";
 import { useHostStore } from "../contexts/HostStoreContext";
+import { Device } from "../native/Device";
 import { SERVER_URL } from "../api";
 import type { PairedHost } from "../types";
 
@@ -85,9 +86,24 @@ export default function PairHost() {
 
       addPairedHost(host);
 
-      // Write hostId to native SharedPreferences for FCM token registration
-      if (Capacitor.isNativePlatform()) {
+      if (Capacitor.isNativePlatform() && Device) {
+        // Native receivers (SmsBroadcastReceiver, DeviceNotificationListenerService)
+        // read hostId to address relay messages.
         await Preferences.set({ key: "hostId", value: response.hostId });
+
+        // Register this device's FCM token with the relay server so it can wake
+        // the device on the paired host's behalf. Moved here from native so the
+        // APK no longer needs to read hostId or trigger registration itself.
+        try {
+          const { token: fcmToken } = await Device.getFcmToken();
+          await fetch(`${SERVER_URL}/api/fcm/register`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ hostId: response.hostId, fcmToken }),
+          });
+        } catch (err) {
+          console.warn("FCM token registration failed:", err);
+        }
       }
 
       navigate("/");

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

@@ -11,7 +11,7 @@ export interface Task {
   name: string;
   user_prompt: string;
   agent?: string;
-  schedule_type?: "crons" | "specific_times";
+  schedule_type?: "crons" | "specific_times" | "on_new_notification" | "on_new_sms";
   schedule_values?: string[];
   schedule_enabled: boolean;
   requires_confirmation: boolean;

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" });
   }
 });