palmier 0.7.2 → 0.7.3

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

@@ -230,6 +230,307 @@ async function main(): Promise<void> {
     }
   })();
 
+  // Subscribe to contacts requests from hosts
+  (async () => {
+    try {
+      const conn = await getNatsConnection();
+      const sub = conn.subscribe("host.*.fcm.contacts");
+      console.log("Listening for FCM contacts requests");
+
+      for await (const msg of sub) {
+        try {
+          const data = JSON.parse(sc.decode(msg.data)) as {
+            hostId: string;
+            requestId: string;
+            fcmToken?: string;
+            action: string;
+            name?: string;
+            phone?: string;
+            email?: string;
+          };
+
+          const subjectHostId = msg.subject.split(".")[1];
+          if (data.hostId !== subjectHostId) {
+            if (msg.reply) {
+              msg.respond(sc.encode(JSON.stringify({ error: "hostId mismatch" })));
+            }
+            continue;
+          }
+
+          const fcmPayload: Record<string, string> = {
+            type: data.action === "create" ? "create-contact" : "read-contacts",
+            requestId: data.requestId,
+            hostId: data.hostId,
+          };
+          if (data.name) fcmPayload.name = data.name;
+          if (data.phone) fcmPayload.phone = data.phone;
+          if (data.email) fcmPayload.email = data.email;
+
+          console.log(`[FCM] Sending contacts ${data.action} request for host ${data.hostId}`);
+          if (data.fcmToken) {
+            await sendFcmToDevice(data.fcmToken, fcmPayload);
+          } else {
+            await sendFcmToClients(data.hostId, fcmPayload);
+          }
+
+          if (msg.reply) {
+            msg.respond(sc.encode(JSON.stringify({ ok: true })));
+          }
+        } catch (err) {
+          console.error("[FCM] Error handling contacts request:", err);
+          if (msg.reply) {
+            msg.respond(sc.encode(JSON.stringify({ error: String(err) })));
+          }
+        }
+      }
+    } catch (err) {
+      console.error("Failed to subscribe to FCM contacts requests:", err);
+    }
+  })();
+
+  // Subscribe to calendar requests from hosts
+  (async () => {
+    try {
+      const conn = await getNatsConnection();
+      const sub = conn.subscribe("host.*.fcm.calendar");
+      console.log("Listening for FCM calendar requests");
+
+      for await (const msg of sub) {
+        try {
+          const data = JSON.parse(sc.decode(msg.data)) as {
+            hostId: string;
+            requestId: string;
+            action: string;
+            [key: string]: string;
+          };
+
+          const subjectHostId = msg.subject.split(".")[1];
+          if (data.hostId !== subjectHostId) {
+            if (msg.reply) {
+              msg.respond(sc.encode(JSON.stringify({ error: "hostId mismatch" })));
+            }
+            continue;
+          }
+
+          const fcmPayload: Record<string, string> = {
+            type: data.action === "create" ? "create-calendar-event" : "read-calendar",
+            requestId: data.requestId,
+            hostId: data.hostId,
+          };
+          // Forward optional fields
+          for (const key of ["startDate", "endDate", "title", "startTime", "endTime", "location", "description"]) {
+            if (data[key]) fcmPayload[key] = data[key];
+          }
+
+          console.log(`[FCM] Sending calendar ${data.action} request for host ${data.hostId}`);
+          await sendFcmToClients(data.hostId, fcmPayload);
+
+          if (msg.reply) {
+            msg.respond(sc.encode(JSON.stringify({ ok: true })));
+          }
+        } catch (err) {
+          console.error("[FCM] Error handling calendar request:", err);
+          if (msg.reply) {
+            msg.respond(sc.encode(JSON.stringify({ error: String(err) })));
+          }
+        }
+      }
+    } catch (err) {
+      console.error("Failed to subscribe to FCM calendar requests:", err);
+    }
+  })();
+
+  // Subscribe to send-SMS requests from hosts
+  (async () => {
+    try {
+      const conn = await getNatsConnection();
+      const sub = conn.subscribe("host.*.fcm.sms");
+      console.log("Listening for FCM SMS requests");
+
+      for await (const msg of sub) {
+        try {
+          const data = JSON.parse(sc.decode(msg.data)) as {
+            hostId: string;
+            requestId: string;
+            action: string;
+            to?: string;
+            body?: string;
+          };
+
+          const subjectHostId = msg.subject.split(".")[1];
+          if (data.hostId !== subjectHostId) {
+            if (msg.reply) {
+              msg.respond(sc.encode(JSON.stringify({ error: "hostId mismatch" })));
+            }
+            continue;
+          }
+
+          const fcmPayload: Record<string, string> = {
+            type: "send-sms",
+            requestId: data.requestId,
+            hostId: data.hostId,
+          };
+          if (data.to) fcmPayload.to = data.to;
+          if (data.body) fcmPayload.body = data.body;
+
+          console.log(`[FCM] Sending SMS request for host ${data.hostId}`);
+          await sendFcmToClients(data.hostId, fcmPayload);
+
+          if (msg.reply) {
+            msg.respond(sc.encode(JSON.stringify({ ok: true })));
+          }
+        } catch (err) {
+          console.error("[FCM] Error handling SMS request:", err);
+          if (msg.reply) {
+            msg.respond(sc.encode(JSON.stringify({ error: String(err) })));
+          }
+        }
+      }
+    } catch (err) {
+      console.error("Failed to subscribe to FCM SMS requests:", err);
+    }
+  })();
+
+  // Subscribe to alarm requests from hosts
+  (async () => {
+    try {
+      const conn = await getNatsConnection();
+      const sub = conn.subscribe("host.*.fcm.alarm");
+      console.log("Listening for FCM alarm requests");
+
+      for await (const msg of sub) {
+        try {
+          const data = JSON.parse(sc.decode(msg.data)) as {
+            hostId: string;
+            requestId: string;
+            [key: string]: string;
+          };
+
+          const subjectHostId = msg.subject.split(".")[1];
+          if (data.hostId !== subjectHostId) {
+            if (msg.reply) {
+              msg.respond(sc.encode(JSON.stringify({ error: "hostId mismatch" })));
+            }
+            continue;
+          }
+
+          const fcmPayload: Record<string, string> = {
+            type: "set-alarm",
+            requestId: data.requestId,
+            hostId: data.hostId,
+          };
+          for (const key of ["hour", "minutes", "label", "days"]) {
+            if (data[key]) fcmPayload[key] = data[key];
+          }
+
+          console.log(`[FCM] Sending alarm request for host ${data.hostId}`);
+          await sendFcmToClients(data.hostId, fcmPayload);
+
+          if (msg.reply) {
+            msg.respond(sc.encode(JSON.stringify({ ok: true })));
+          }
+        } catch (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 alarm requests:", err);
+    }
+  })();
+
+  // Subscribe to battery requests from hosts
+  (async () => {
+    try {
+      const conn = await getNatsConnection();
+      const sub = conn.subscribe("host.*.fcm.battery");
+      console.log("Listening for FCM battery requests");
+
+      for await (const msg of sub) {
+        try {
+          const data = JSON.parse(sc.decode(msg.data)) as {
+            hostId: string;
+            requestId: string;
+          };
+
+          const subjectHostId = msg.subject.split(".")[1];
+          if (data.hostId !== subjectHostId) {
+            if (msg.reply) {
+              msg.respond(sc.encode(JSON.stringify({ error: "hostId mismatch" })));
+            }
+            continue;
+          }
+
+          console.log(`[FCM] Sending battery request for host ${data.hostId}`);
+          await sendFcmToClients(data.hostId, {
+            type: "read-battery",
+            requestId: data.requestId,
+            hostId: data.hostId,
+          });
+
+          if (msg.reply) {
+            msg.respond(sc.encode(JSON.stringify({ ok: true })));
+          }
+        } catch (err) {
+          console.error("[FCM] Error handling battery request:", err);
+          if (msg.reply) {
+            msg.respond(sc.encode(JSON.stringify({ error: String(err) })));
+          }
+        }
+      }
+    } catch (err) {
+      console.error("Failed to subscribe to FCM battery requests:", err);
+    }
+  })();
+
+  // Subscribe to ringer mode requests from hosts
+  (async () => {
+    try {
+      const conn = await getNatsConnection();
+      const sub = conn.subscribe("host.*.fcm.ringer");
+      console.log("Listening for FCM ringer requests");
+
+      for await (const msg of sub) {
+        try {
+          const data = JSON.parse(sc.decode(msg.data)) as {
+            hostId: string;
+            requestId: string;
+            mode: string;
+          };
+
+          const subjectHostId = msg.subject.split(".")[1];
+          if (data.hostId !== subjectHostId) {
+            if (msg.reply) {
+              msg.respond(sc.encode(JSON.stringify({ error: "hostId mismatch" })));
+            }
+            continue;
+          }
+
+          console.log(`[FCM] Sending ringer mode request for host ${data.hostId}`);
+          await sendFcmToClients(data.hostId, {
+            type: "set-ringer-mode",
+            requestId: data.requestId,
+            hostId: data.hostId,
+            mode: data.mode,
+          });
+
+          if (msg.reply) {
+            msg.respond(sc.encode(JSON.stringify({ ok: true })));
+          }
+        } catch (err) {
+          console.error("[FCM] Error handling ringer request:", err);
+          if (msg.reply) {
+            msg.respond(sc.encode(JSON.stringify({ error: String(err) })));
+          }
+        }
+      }
+    } catch (err) {
+      console.error("Failed to subscribe to FCM ringer requests:", err);
+    }
+  })();
+
   // Create Express app
   const app = express();
 

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

@@ -29,4 +29,172 @@ router.post("/notifications", async (req: Request, res: Response) => {
   }
 });
 
+// POST /api/device/sms - Receive an SMS from Android, relay to host via NATS
+router.post("/sms", async (req: Request, res: Response) => {
+  try {
+    const { hostId, sms } = req.body;
+
+    if (!hostId || !sms?.id) {
+      res.status(400).json({ error: "hostId and sms with id are required" });
+      return;
+    }
+
+    const conn = await getNatsConnection();
+    const sc = StringCodec();
+    conn.publish(
+      `host.${hostId}.device.sms`,
+      sc.encode(JSON.stringify(sms)),
+    );
+
+    res.json({ ok: true });
+  } catch (err) {
+    console.error("Device SMS relay error:", err);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+// POST /api/device/contacts-response - Receive contacts response from Android, relay to host via NATS
+router.post("/contacts-response", async (req: Request, res: Response) => {
+  try {
+    const { requestId, hostId, result } = req.body;
+
+    if (!requestId || !hostId) {
+      res.status(400).json({ error: "requestId and hostId are required" });
+      return;
+    }
+
+    const conn = await getNatsConnection();
+    const sc = StringCodec();
+    conn.publish(
+      `host.${hostId}.contacts.${requestId}`,
+      sc.encode(JSON.stringify(result)),
+    );
+
+    res.json({ ok: true });
+  } catch (err) {
+    console.error("Device contacts response relay error:", err);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+// POST /api/device/calendar-response - Receive calendar response from Android, relay to host via NATS
+router.post("/calendar-response", async (req: Request, res: Response) => {
+  try {
+    const { requestId, hostId, result } = req.body;
+
+    if (!requestId || !hostId) {
+      res.status(400).json({ error: "requestId and hostId are required" });
+      return;
+    }
+
+    const conn = await getNatsConnection();
+    const sc = StringCodec();
+    conn.publish(
+      `host.${hostId}.calendar.${requestId}`,
+      sc.encode(JSON.stringify(result)),
+    );
+
+    res.json({ ok: true });
+  } catch (err) {
+    console.error("Device calendar response relay error:", err);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+// POST /api/device/sms-response - Receive SMS send response from Android, relay to host via NATS
+router.post("/sms-response", async (req: Request, res: Response) => {
+  try {
+    const { requestId, hostId, result } = req.body;
+
+    if (!requestId || !hostId) {
+      res.status(400).json({ error: "requestId and hostId are required" });
+      return;
+    }
+
+    const conn = await getNatsConnection();
+    const sc = StringCodec();
+    conn.publish(
+      `host.${hostId}.sms.${requestId}`,
+      sc.encode(JSON.stringify(result)),
+    );
+
+    res.json({ ok: true });
+  } catch (err) {
+    console.error("Device SMS response relay error:", err);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+// 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;
+
+    if (!requestId || !hostId) {
+      res.status(400).json({ error: "requestId and hostId are required" });
+      return;
+    }
+
+    const conn = await getNatsConnection();
+    const sc = StringCodec();
+    conn.publish(
+      `host.${hostId}.alarm.${requestId}`,
+      sc.encode(JSON.stringify(result)),
+    );
+
+    res.json({ ok: true });
+  } catch (err) {
+    console.error("Device alarm response relay error:", err);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+// POST /api/device/battery-response - Receive battery response from Android, relay to host via NATS
+router.post("/battery-response", async (req: Request, res: Response) => {
+  try {
+    const { requestId, hostId, result } = req.body;
+
+    if (!requestId || !hostId) {
+      res.status(400).json({ error: "requestId and hostId are required" });
+      return;
+    }
+
+    const conn = await getNatsConnection();
+    const sc = StringCodec();
+    conn.publish(
+      `host.${hostId}.battery.${requestId}`,
+      sc.encode(JSON.stringify(result)),
+    );
+
+    res.json({ ok: true });
+  } catch (err) {
+    console.error("Device battery response relay error:", err);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+// POST /api/device/ringer-response - Receive ringer mode response from Android, relay to host via NATS
+router.post("/ringer-response", async (req: Request, res: Response) => {
+  try {
+    const { requestId, hostId, result } = req.body;
+
+    if (!requestId || !hostId) {
+      res.status(400).json({ error: "requestId and hostId are required" });
+      return;
+    }
+
+    const conn = await getNatsConnection();
+    const sc = StringCodec();
+    conn.publish(
+      `host.${hostId}.ringer.${requestId}`,
+      sc.encode(JSON.stringify(result)),
+    );
+
+    res.json({ ok: true });
+  } catch (err) {
+    console.error("Device ringer response relay error:", err);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
 export default router;

package/palmier-server/spec.md

@@ -12,11 +12,22 @@ 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`. The same tools are auto-generated as REST endpoints (`/notify`, `/request-input`, etc.) from a shared tool registry — zero duplication. REST endpoints require `taskId` in the body for session identification. `/request-permission` remains a separate endpoint (not part of the MCP tool registry). 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 `getPlanGenerationCommandLine()`, `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`, `set-alarm`, `read-battery`, `set-ringer-mode`; and resources: `notifications://device` (device notifications), `sms://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. Co-located with the NATS server on the same machine.
+* **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 and `FusedLocationProviderClient` for GPS access. When a geolocation request arrives via FCM, a foreground service briefly starts to fetch the GPS fix and POST the result back to the Web Server. See the `palmier-android` repo.
+* **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)
+  - **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)
+  - **Battery**: `BatteryHandler` — no permission required
+  - **Ringer mode**: `RingerHandler` — requires Do Not Disturb access (system settings toggle)
+
+  The notification listener excludes Palmier's own task notifications (channel `palmier_tasks`) and the default SMS app's notifications (to avoid duplicates with the SMS resource). Each capability can be toggled on/off via the app's settings menu; toggles are backed by SharedPreferences flags that handlers check before executing. See the `palmier-android` repo.
 
 * **PWA (React):** The user-facing frontend, primarily targeting mobile devices. Connects to the NATS server via **WebSockets** at `nats.palmier.me` (DNS only, not Cloudflare proxied, to avoid interference with persistent connections). No user accounts — paired hosts are stored in localStorage.
 
@@ -135,6 +146,8 @@ All RPC requests include a `clientToken` field in the JSON payload. The host val
 | Subject | Payload | Subscriber | Description |
 |---|---|---|---|
 | `host-event.<host_id>.<task_id>` | `{ event_type, ... }` | PWA, Web Server | Unified event subject. `event_type` is one of `"running-state"`, `"confirm-request"`, `"confirm-resolved"`, `"permission-request"`, `"permission-resolved"`, or `"report-generated"`. Payloads: running-state includes `{ running_state, name? }`, confirm-request includes `{ host_id }`, confirm-resolved includes `{ host_id, status }`, report-generated includes `{ name?, run_id, report_files }`. Same payload shape is used for both NATS and HTTP SSE. |
+| `host.<host_id>.device.notifications` | `{ id, packageName, appName, title, text, timestamp }` | Host | Device notification from Android. Published by Web Server when it receives `POST /api/device/notifications` from the Android app. Host stores in bounded in-memory collection and exposes via MCP resource. |
+| `host.<host_id>.device.sms` | `{ id, sender, body, timestamp }` | Host | Incoming SMS from Android. Published by Web Server when it receives `POST /api/device/sms` from the Android app. Host stores in bounded in-memory collection and exposes via MCP resource. |
 
 ### 2.5 Push Subscription Management
 
@@ -381,6 +394,14 @@ The serve daemon exposes localhost-only HTTP endpoints that agents call during t
 
 * **`POST /request-permission`** — Requests permission grants. Body: `{ taskId, taskName, permissions }`. Called by `palmier run` (not agents). Returns `{ response: "granted" | "granted_all" | "aborted" }`.
 
+### 6.2 Resource Endpoints
+
+Resource REST endpoints are auto-generated from the `ResourceDefinition[]` registry in `mcp-tools.ts`. Each resource exposes a GET endpoint at its `restPath`. These are also available via the MCP protocol (`resources/list`, `resources/read`).
+
+* **`GET /notifications`** — Returns recent notifications from the user's Android device as a JSON array. Each notification contains `{ id, packageName, appName, title, text, timestamp, receivedAt }`. The host maintains a bounded in-memory collection (last 50 notifications) fed by NATS subscription to `host.<host_id>.device.notifications`.
+
+* **`GET /sms`** — Returns recent SMS messages from the user's Android device as a JSON array. Each message contains `{ id, sender, body, timestamp, receivedAt }`. The host maintains a bounded in-memory collection (last 50 messages) fed by NATS subscription to `host.<host_id>.device.sms`.
+
 ## 7. Database Schema (PostgreSQL)
 
 ```sql
@@ -415,4 +436,12 @@ All endpoints are served over HTTPS. No user authentication is required — the
 | `DELETE` | `/api/push/subscribe` | Unregister a push subscription. Body: `{ hostId, endpoint }`. |
 | `GET`  | `/api/push/vapid-key` | Returns the server's VAPID public key for push subscription. |
 | `POST` | `/api/push/respond` | Called by Service Worker to relay user responses to task confirmations. Body: `{ type, task_id, host_id, response }`. Web Server forwards the response to the host via the `host.<host_id>.rpc.task.user_input` NATS RPC. |
+| `POST` | `/api/device/notifications` | Relay a device notification from Android to the host. Body: `{ hostId, notification: { id, packageName, appName, title, text, timestamp } }`. Publishes to NATS `host.<hostId>.device.notifications`. |
+| `POST` | `/api/device/sms` | Relay an incoming SMS from Android to the host. Body: `{ hostId, sms: { id, sender, body, timestamp } }`. Publishes to NATS `host.<hostId>.device.sms`. |
+| `POST` | `/api/device/contacts-response` | Relay contacts response from Android to the host. Body: `{ requestId, hostId, result }`. Publishes to NATS `host.<hostId>.contacts.<requestId>`. |
+| `POST` | `/api/device/calendar-response` | Relay calendar response from Android to the host. Body: `{ requestId, hostId, result }`. Publishes to NATS `host.<hostId>.calendar.<requestId>`. |
+| `POST` | `/api/device/sms-response` | Relay SMS send response from Android to the host. Body: `{ requestId, hostId, result }`. Publishes to NATS `host.<hostId>.sms.<requestId>`. |
+| `POST` | `/api/device/alarm-response` | Relay alarm response from Android to the host. Body: `{ requestId, hostId, result }`. Publishes to NATS `host.<hostId>.alarm.<requestId>`. |
+| `POST` | `/api/device/battery-response` | Relay battery response from Android to the host. Body: `{ requestId, hostId, result }`. Publishes to NATS `host.<hostId>.battery.<requestId>`. |
+| `POST` | `/api/device/ringer-response` | Relay ringer mode response from Android to the host. Body: `{ requestId, hostId, result }`. Publishes to NATS `host.<hostId>.ringer.<requestId>`. |
 | `GET`  | `/health` | Health check. |

package/src/commands/serve.ts

@@ -14,6 +14,7 @@ import type { HostConfig } from "../types.js";
 import { CONFIG_DIR } from "../config.js";
 import { StringCodec, type NatsConnection } from "nats";
 import { addNotification } from "../notification-store.js";
+import { addSmsMessage } from "../sms-store.js";
 
 const POLL_INTERVAL_MS = 30_000;
 const DAEMON_PID_FILE = path.join(CONFIG_DIR, "daemon.pid");
@@ -132,7 +133,7 @@ export async function serveCommand(): Promise<void> {
   if (nc) {
     startNatsTransport(config, handleRpc, nc);
 
-    // Subscribe to device notifications from Android
+    // Subscribe to device notifications and SMS from Android
     const sc = StringCodec();
     const notifSub = nc.subscribe(`host.${config.hostId}.device.notifications`);
     (async () => {
@@ -145,6 +146,18 @@ export async function serveCommand(): Promise<void> {
         }
       }
     })();
+
+    const smsSub = nc.subscribe(`host.${config.hostId}.device.sms`);
+    (async () => {
+      for await (const msg of smsSub) {
+        try {
+          const data = JSON.parse(sc.decode(msg.data));
+          addSmsMessage({ ...data, receivedAt: Date.now() });
+        } catch (err) {
+          console.error("[nats] Failed to parse device SMS:", err);
+        }
+      }
+    })();
   }
 
   // Start HTTP transport (loops forever)

package/src/mcp-handler.ts

@@ -157,12 +157,15 @@ export async function handleMcpRequest(body: string, sessionId: string | undefin
       if (!resource) {
         return { body: rpcError(id, -32602, `Unknown resource: ${uri}`) };
       }
+      console.log(`${logPrefix} resources/read ${uri}`);
+      const content = resource.read();
+      console.log(`${logPrefix} resources/read ${uri} done: ${JSON.stringify(content).slice(0, 200)}`);
       return {
         body: rpcResult(id, {
           contents: [{
             uri: resource.uri,
             mimeType: resource.mimeType,
-            text: JSON.stringify(resource.read()),
+            text: JSON.stringify(content),
           }],
         }),
       };