palmier 0.7.3 → 0.7.6

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

@@ -47,7 +47,7 @@ export default function Dashboard() {
   const [updating, setUpdating] = useState(false);
   const [updateError, setUpdateError] = useState<string | null>(null);
   const [daemonVersion, setDaemonVersion] = useState<string | null>(null);
-  const [locationClientToken, setLocationClientToken] = useState<string | null>(null);
+  const [capabilityTokens, setCapabilityTokens] = useState<Record<string, string | null>>({});
 
   // Register push subscription for the active host
   usePushSubscription();
@@ -88,11 +88,11 @@ export default function Dashboard() {
 
   return (
     <div className="dashboard">
-      {isDesktop && <HostMenu daemonVersion={daemonVersion} locationClientToken={locationClientToken} activeClientToken={activeClientToken} request={request} onLocationClientTokenChange={setLocationClientToken} />}
+      {isDesktop && <HostMenu daemonVersion={daemonVersion} capabilityTokens={capabilityTokens} activeClientToken={activeClientToken} request={request} onCapabilityTokensChange={setCapabilityTokens} />}
 
       <div className="dashboard-content">
         <div className="tab-bar">
-          {!isDesktop && <HostMenu daemonVersion={daemonVersion} locationClientToken={locationClientToken} activeClientToken={activeClientToken} request={request} onLocationClientTokenChange={setLocationClientToken} />}
+          {!isDesktop && <HostMenu daemonVersion={daemonVersion} capabilityTokens={capabilityTokens} activeClientToken={activeClientToken} request={request} onCapabilityTokensChange={setCapabilityTokens} />}
           <TabBar />
         </div>
 
@@ -141,7 +141,7 @@ export default function Dashboard() {
                 onViewRun={handleViewRun}
                 onUpdateRequired={setUpdateRequired}
                 onVersion={setDaemonVersion}
-                onLocationClientToken={setLocationClientToken}
+                onCapabilityTokens={setCapabilityTokens}
               />
             </div>
             {isRunDetail ? (

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

@@ -391,19 +391,21 @@ async function main(): Promise<void> {
     }
   })();
 
-  // Subscribe to alarm requests from hosts
+  // Subscribe to alert requests from hosts
   (async () => {
     try {
       const conn = await getNatsConnection();
-      const sub = conn.subscribe("host.*.fcm.alarm");
-      console.log("Listening for FCM alarm requests");
+      const sub = conn.subscribe("host.*.fcm.alert");
+      console.log("Listening for FCM alert requests");
 
       for await (const msg of sub) {
         try {
           const data = JSON.parse(sc.decode(msg.data)) as {
             hostId: string;
             requestId: string;
-            [key: string]: string;
+            fcmToken?: string;
+            title?: string;
+            description?: string;
           };
 
           const subjectHostId = msg.subject.split(".")[1];
@@ -415,29 +417,32 @@ async function main(): Promise<void> {
           }
 
           const fcmPayload: Record<string, string> = {
-            type: "set-alarm",
+            type: "send-alert",
             requestId: data.requestId,
             hostId: data.hostId,
           };
-          for (const key of ["hour", "minutes", "label", "days"]) {
-            if (data[key]) fcmPayload[key] = data[key];
-          }
+          if (data.title) fcmPayload.title = data.title;
+          if (data.description) fcmPayload.description = data.description;
 
-          console.log(`[FCM] Sending alarm request for host ${data.hostId}`);
-          await sendFcmToClients(data.hostId, fcmPayload);
+          console.log(`[FCM] Sending alert 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 alarm request:", err);
+          console.error("[FCM] Error handling alert 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);
+      console.error("Failed to subscribe to FCM alert 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/alarm-response - Receive alarm response from Android, relay to host via NATS
-router.post("/alarm-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) => {
   try {
     const { requestId, hostId, result } = req.body;
 
@@ -138,13 +138,13 @@ router.post("/alarm-response", async (req: Request, res: Response) => {
     const conn = await getNatsConnection();
     const sc = StringCodec();
     conn.publish(
-      `host.${hostId}.alarm.${requestId}`,
+      `host.${hostId}.alert.${requestId}`,
       sc.encode(JSON.stringify(result)),
     );
 
     res.json({ ok: true });
   } catch (err) {
-    console.error("Device alarm response relay error:", err);
+    console.error("Device alert response relay error:", err);
     res.status(500).json({ error: "Internal server error" });
   }
 });

package/palmier-server/spec.md

@@ -12,7 +12,7 @@ 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`, `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.
+* **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.
 
 * **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.
 
@@ -400,7 +400,7 @@ Resource REST endpoints are auto-generated from the `ResourceDefinition[]` regis
 
 * **`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`.
+* **`GET /sms-messages`** — 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)
 

package/src/device-capabilities.ts

@@ -0,0 +1,55 @@
+import * as fs from "fs";
+import * as path from "path";
+import { CONFIG_DIR } from "./config.js";
+
+const CAPABILITIES_FILE = path.join(CONFIG_DIR, "device-capabilities.json");
+
+export interface RegisteredDevice {
+  clientToken: string;
+  fcmToken: string;
+}
+
+export type DeviceCapability =
+  | "location"
+  | "notifications"
+  | "sms"
+  | "contacts"
+  | "calendar"
+  | "alert"
+  | "battery"
+  | "dnd";
+
+type CapabilityMap = Partial<Record<DeviceCapability, RegisteredDevice>>;
+
+function readAll(): CapabilityMap {
+  try {
+    if (!fs.existsSync(CAPABILITIES_FILE)) return {};
+    return JSON.parse(fs.readFileSync(CAPABILITIES_FILE, "utf-8")) as CapabilityMap;
+  } catch {
+    return {};
+  }
+}
+
+function writeAll(map: CapabilityMap): void {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CAPABILITIES_FILE, JSON.stringify(map, null, 2), "utf-8");
+}
+
+export function getCapabilityDevice(capability: DeviceCapability): RegisteredDevice | null {
+  const map = readAll();
+  const device = map[capability];
+  if (!device?.clientToken || !device?.fcmToken) return null;
+  return device;
+}
+
+export function setCapabilityDevice(capability: DeviceCapability, clientToken: string, fcmToken: string): void {
+  const map = readAll();
+  map[capability] = { clientToken, fcmToken };
+  writeAll(map);
+}
+
+export function clearCapabilityDevice(capability: DeviceCapability): void {
+  const map = readAll();
+  delete map[capability];
+  writeAll(map);
+}

package/src/mcp-tools.ts

@@ -1,6 +1,6 @@
 import { StringCodec, type NatsConnection } from "nats";
 import { registerPending } from "./pending-requests.js";
-import { getLocationDevice } from "./location-device.js";
+import { getCapabilityDevice } from "./device-capabilities.js";
 import { getNotifications } from "./notification-store.js";
 import { getSmsMessages } from "./sms-store.js";
 import type { HostConfig } from "./types.js";
@@ -170,14 +170,14 @@ const deviceGeolocationTool: ToolDefinition = {
   async handler(_args, ctx) {
     if (!ctx.nc) throw new ToolError("Not connected to server (NATS unavailable)", 503);
 
-    const locDevice = getLocationDevice();
-    if (!locDevice) throw new ToolError("No device has location access enabled", 400);
+    const device = getCapabilityDevice("location");
+    if (!device) throw new ToolError("No device has location access enabled", 400);
 
     const sc = StringCodec();
 
     const ackReply = await ctx.nc.request(
       `host.${ctx.config.hostId}.fcm.geolocation`,
-      sc.encode(JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.sessionId, fcmToken: locDevice.fcmToken })),
+      sc.encode(JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.sessionId, fcmToken: device.fcmToken })),
       { timeout: 5_000 },
     );
     const ack = JSON.parse(sc.decode(ackReply.data)) as { ok?: boolean; error?: string };
@@ -218,11 +218,14 @@ const readContactsTool: ToolDefinition = {
   async handler(_args, ctx) {
     if (!ctx.nc) throw new ToolError("Not connected to server (NATS unavailable)", 503);
 
+    const device = getCapabilityDevice("contacts");
+    if (!device) throw new ToolError("No device has contacts access enabled", 400);
+
     const sc = StringCodec();
 
     const ackReply = await ctx.nc.request(
       `host.${ctx.config.hostId}.fcm.contacts`,
-      sc.encode(JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.sessionId, action: "read" })),
+      sc.encode(JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.sessionId, fcmToken: device.fcmToken, action: "read" })),
       { timeout: 5_000 },
     );
     const ack = JSON.parse(sc.decode(ackReply.data)) as { ok?: boolean; error?: string };
@@ -268,6 +271,9 @@ const createContactTool: ToolDefinition = {
   async handler(args, ctx) {
     if (!ctx.nc) throw new ToolError("Not connected to server (NATS unavailable)", 503);
 
+    const device = getCapabilityDevice("contacts");
+    if (!device) throw new ToolError("No device has contacts access enabled", 400);
+
     const { name, phone, email } = args as { name: string; phone?: string; email?: string };
     if (!name) throw new ToolError("name is required", 400);
 
@@ -276,7 +282,7 @@ const createContactTool: ToolDefinition = {
     const ackReply = await ctx.nc.request(
       `host.${ctx.config.hostId}.fcm.contacts`,
       sc.encode(JSON.stringify({
-        hostId: ctx.config.hostId, requestId: ctx.sessionId,
+        hostId: ctx.config.hostId, requestId: ctx.sessionId, fcmToken: device.fcmToken,
         action: "create", name, phone, email,
       })),
       { timeout: 5_000 },
@@ -323,13 +329,16 @@ const readCalendarTool: ToolDefinition = {
   async handler(args, ctx) {
     if (!ctx.nc) throw new ToolError("Not connected to server (NATS unavailable)", 503);
 
+    const device = getCapabilityDevice("calendar");
+    if (!device) throw new ToolError("No device has calendar access enabled", 400);
+
     const { startDate, endDate } = args as { startDate?: number; endDate?: number };
     const sc = StringCodec();
 
     const ackReply = await ctx.nc.request(
       `host.${ctx.config.hostId}.fcm.calendar`,
       sc.encode(JSON.stringify({
-        hostId: ctx.config.hostId, requestId: ctx.sessionId,
+        hostId: ctx.config.hostId, requestId: ctx.sessionId, fcmToken: device.fcmToken,
         action: "read",
         ...(startDate ? { startDate: String(startDate) } : {}),
         ...(endDate ? { endDate: String(endDate) } : {}),
@@ -381,6 +390,9 @@ const createCalendarEventTool: ToolDefinition = {
   async handler(args, ctx) {
     if (!ctx.nc) throw new ToolError("Not connected to server (NATS unavailable)", 503);
 
+    const device = getCapabilityDevice("calendar");
+    if (!device) throw new ToolError("No device has calendar access enabled", 400);
+
     const { title, startTime, endTime, location, description } = args as {
       title: string; startTime: number; endTime: number; location?: string; description?: string;
     };
@@ -391,7 +403,7 @@ const createCalendarEventTool: ToolDefinition = {
     const ackReply = await ctx.nc.request(
       `host.${ctx.config.hostId}.fcm.calendar`,
       sc.encode(JSON.stringify({
-        hostId: ctx.config.hostId, requestId: ctx.sessionId,
+        hostId: ctx.config.hostId, requestId: ctx.sessionId, fcmToken: device.fcmToken,
         action: "create",
         title, startTime: String(startTime), endTime: String(endTime),
         ...(location ? { location } : {}),
@@ -424,7 +436,7 @@ const createCalendarEventTool: ToolDefinition = {
 };
 
 const sendSmsTool: ToolDefinition = {
-  name: "send-sms",
+  name: "send-sms-message",
   description: [
     "Send an SMS message from the user's mobile device.",
     "Blocks until the device responds (up to 30 seconds).",
@@ -441,6 +453,9 @@ const sendSmsTool: ToolDefinition = {
   async handler(args, ctx) {
     if (!ctx.nc) throw new ToolError("Not connected to server (NATS unavailable)", 503);
 
+    const device = getCapabilityDevice("sms");
+    if (!device) throw new ToolError("No device has SMS access enabled", 400);
+
     const { to, body } = args as { to: string; body: string };
     if (!to || !body) throw new ToolError("to and body are required", 400);
 
@@ -449,7 +464,7 @@ const sendSmsTool: ToolDefinition = {
     const ackReply = await ctx.nc.request(
       `host.${ctx.config.hostId}.fcm.sms`,
       sc.encode(JSON.stringify({
-        hostId: ctx.config.hostId, requestId: ctx.sessionId,
+        hostId: ctx.config.hostId, requestId: ctx.sessionId, fcmToken: device.fcmToken,
         action: "send", to, body,
       })),
       { timeout: 5_000 },
@@ -478,44 +493,41 @@ const sendSmsTool: ToolDefinition = {
   },
 };
 
-const setAlarmTool: ToolDefinition = {
-  name: "set-alarm",
+const sendAlertTool: ToolDefinition = {
+  name: "send-alert",
   description: [
-    "Set an alarm on the user's mobile device.",
+    "Send an alert to the user's mobile device with an alarm sound and full-screen popup.",
+    "Use this to urgently get the user's attention. The device will play an alarm sound and show a full-screen dialog even on the lock screen.",
     "Blocks until the device responds (up to 30 seconds).",
     'Response: `{"ok": true}` on success, or `{"error": "..."}` on failure.',
   ],
   inputSchema: {
     type: "object",
     properties: {
-      hour: { type: "number", description: "Hour (0-23)" },
-      minutes: { type: "number", description: "Minutes (0-59)" },
-      label: { type: "string", description: "Alarm label" },
-      days: {
-        type: "array",
-        items: { type: "number" },
-        description: "Recurring days (1=Sun, 2=Mon, ..., 7=Sat). Omit for one-time.",
-      },
+      title: { type: "string", description: "Alert title" },
+      description: { type: "string", description: "Alert description/details" },
     },
-    required: ["hour", "minutes"],
+    required: ["title"],
   },
   async handler(args, ctx) {
     if (!ctx.nc) throw new ToolError("Not connected to server (NATS unavailable)", 503);
 
-    const { hour, minutes, label, days } = args as { hour: number; minutes: number; label?: string; days?: number[] };
-    if (hour == null || minutes == null) throw new ToolError("hour and minutes are required", 400);
+    const device = getCapabilityDevice("alert");
+    if (!device) throw new ToolError("No device has alert access enabled", 400);
+
+    const { title, description } = args as { title: string; description?: string };
+    if (!title) throw new ToolError("title is required", 400);
 
     const sc = StringCodec();
 
-    const payload: Record<string, unknown> = {
-      hostId: ctx.config.hostId, requestId: ctx.sessionId,
-      action: "set", hour: String(hour), minutes: String(minutes),
+    const payload: Record<string, string> = {
+      hostId: ctx.config.hostId, requestId: ctx.sessionId, fcmToken: device.fcmToken,
+      title,
     };
-    if (label) payload.label = label;
-    if (days?.length) payload.days = days.join(",");
+    if (description) payload.description = description;
 
     const ackReply = await ctx.nc.request(
-      `host.${ctx.config.hostId}.fcm.alarm`,
+      `host.${ctx.config.hostId}.fcm.alert`,
       sc.encode(JSON.stringify(payload)),
       { timeout: 5_000 },
     );
@@ -523,7 +535,7 @@ const setAlarmTool: ToolDefinition = {
     if (ack.error) throw new ToolError(ack.error, 502);
 
     const responsePromise = new Promise<string>((resolve, reject) => {
-      const sub = ctx.nc!.subscribe(`host.${ctx.config.hostId}.alarm.${ctx.sessionId}`, { max: 1 });
+      const sub = ctx.nc!.subscribe(`host.${ctx.config.hostId}.alert.${ctx.sessionId}`, { max: 1 });
       const timer = setTimeout(() => {
         sub.unsubscribe();
         reject(new ToolError("Device did not respond within 30 seconds", 504));
@@ -557,11 +569,14 @@ const readBatteryTool: ToolDefinition = {
   async handler(_args, ctx) {
     if (!ctx.nc) throw new ToolError("Not connected to server (NATS unavailable)", 503);
 
+    const device = getCapabilityDevice("battery");
+    if (!device) throw new ToolError("No device has battery access enabled", 400);
+
     const sc = StringCodec();
 
     const ackReply = await ctx.nc.request(
       `host.${ctx.config.hostId}.fcm.battery`,
-      sc.encode(JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.sessionId })),
+      sc.encode(JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.sessionId, fcmToken: device.fcmToken })),
       { timeout: 5_000 },
     );
     const ack = JSON.parse(sc.decode(ackReply.data)) as { ok?: boolean; error?: string };
@@ -605,6 +620,9 @@ const setRingerModeTool: ToolDefinition = {
   async handler(args, ctx) {
     if (!ctx.nc) throw new ToolError("Not connected to server (NATS unavailable)", 503);
 
+    const device = getCapabilityDevice("dnd");
+    if (!device) throw new ToolError("No device has Do Not Disturb control enabled", 400);
+
     const { mode } = args as { mode: string };
     if (!["normal", "vibrate", "silent"].includes(mode)) throw new ToolError("mode must be 'normal', 'vibrate', or 'silent'", 400);
 
@@ -612,7 +630,7 @@ const setRingerModeTool: ToolDefinition = {
 
     const ackReply = await ctx.nc.request(
       `host.${ctx.config.hostId}.fcm.ringer`,
-      sc.encode(JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.sessionId, mode })),
+      sc.encode(JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.sessionId, fcmToken: device.fcmToken, mode })),
       { timeout: 5_000 },
     );
     const ack = JSON.parse(sc.decode(ackReply.data)) as { ok?: boolean; error?: string };
@@ -639,7 +657,7 @@ const setRingerModeTool: ToolDefinition = {
   },
 };
 
-export const agentTools: ToolDefinition[] = [notifyTool, requestInputTool, requestConfirmationTool, deviceGeolocationTool, readContactsTool, createContactTool, readCalendarTool, createCalendarEventTool, sendSmsTool, setAlarmTool, readBatteryTool, setRingerModeTool];
+export const agentTools: ToolDefinition[] = [notifyTool, requestInputTool, requestConfirmationTool, deviceGeolocationTool, readContactsTool, createContactTool, readCalendarTool, createCalendarEventTool, sendSmsTool, sendAlertTool, readBatteryTool, setRingerModeTool];
 export const agentToolMap = new Map<string, ToolDefinition>(agentTools.map((t) => [t.name, t]));
 
 // ── MCP Resources ─────────────────────────────────────────────────────
@@ -671,14 +689,14 @@ const deviceNotificationsResource: ResourceDefinition = {
 };
 
 const deviceSmsResource: ResourceDefinition = {
-  uri: "sms://device",
+  uri: "sms-messages://device",
   name: "Device SMS",
   description: [
     "Get recent SMS messages from the user's Android device.",
     "Response: JSON array of message objects with `id`, `sender`, `body`, `timestamp`.",
   ],
   mimeType: "application/json",
-  restPath: "/sms",
+  restPath: "/sms-messages",
   read: getSmsMessages,
 };
 

package/src/rpc-handler.ts

@@ -11,7 +11,7 @@ import crossSpawn from "cross-spawn";
 import { getAgent } from "./agents/agent.js";
 import { validateClient } from "./client-store.js";
 import { publishHostEvent } from "./events.js";
-import { getLocationDevice, setLocationDevice, clearLocationDevice } from "./location-device.js";
+import { getCapabilityDevice, setCapabilityDevice, clearCapabilityDevice, type DeviceCapability } from "./device-capabilities.js";
 import { currentVersion, performUpdate } from "./update-checker.js";
 import { parseReportFiles, parseTaskOutcome, stripPalmierMarkers } from "./commands/run.js";
 import type { HostConfig, ParsedTask, RpcMessage, ConversationMessage } from "./types.js";
@@ -163,13 +163,17 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
     switch (request.method) {
       case "task.list": {
         const tasks = listTasks(config.projectRoot);
-        const locDevice = getLocationDevice();
+        const capabilities: Record<string, string | null> = {};
+        for (const cap of ["location", "notifications", "sms", "contacts", "calendar", "alert", "battery", "dnd"] as const) {
+          capabilities[cap] = getCapabilityDevice(cap)?.clientToken ?? null;
+        }
         return {
           tasks: tasks.map((task) => flattenTask(task)),
           agents: config.agents ?? [],
           version: currentVersion,
           host_platform: process.platform,
-          location_client_token: locDevice?.clientToken ?? null,
+          location_client_token: capabilities.location,
+          capability_tokens: capabilities,
         };
       }
 
@@ -652,12 +656,27 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         const params = request.params as { fcmToken: string };
         if (!params.fcmToken) return { error: "fcmToken is required" };
         const clientToken = request.clientToken ?? "";
-        setLocationDevice(clientToken, params.fcmToken);
+        setCapabilityDevice("location", clientToken, params.fcmToken);
         return { ok: true };
       }
 
       case "device.location.disable": {
-        clearLocationDevice();
+        clearCapabilityDevice("location");
+        return { ok: true };
+      }
+
+      case "device.capability.enable": {
+        const params = request.params as { capability: DeviceCapability; fcmToken: string };
+        if (!params.capability || !params.fcmToken) return { error: "capability and fcmToken are required" };
+        const clientToken = request.clientToken ?? "";
+        setCapabilityDevice(params.capability, clientToken, params.fcmToken);
+        return { ok: true };
+      }
+
+      case "device.capability.disable": {
+        const params = request.params as { capability: DeviceCapability };
+        if (!params.capability) return { error: "capability is required" };
+        clearCapabilityDevice(params.capability);
         return { ok: true };
       }
 

package/src/transports/http-transport.ts

@@ -125,7 +125,7 @@ export async function startHttpTransport(
 
   // Wire up resource change listeners
   onNotificationsChanged(() => broadcastResourceUpdated("notifications://device"));
-  onSmsChanged(() => broadcastResourceUpdated("sms://device"));
+  onSmsChanged(() => broadcastResourceUpdated("sms-messages://device"));
 
   // If a pairing code is provided, pre-register it
   if (pairingCode) {

package/dist/location-device.d.ts

@@ -1,8 +0,0 @@
-export interface LocationDevice {
-    clientToken: string;
-    fcmToken: string;
-}
-export declare function getLocationDevice(): LocationDevice | null;
-export declare function setLocationDevice(clientToken: string, fcmToken: string): void;
-export declare function clearLocationDevice(): void;
-//# sourceMappingURL=location-device.d.ts.map

package/dist/location-device.js

@@ -1,32 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { CONFIG_DIR } from "./config.js";
-const LOCATION_FILE = path.join(CONFIG_DIR, "location-device.json");
-export function getLocationDevice() {
-    try {
-        if (!fs.existsSync(LOCATION_FILE))
-            return null;
-        const raw = fs.readFileSync(LOCATION_FILE, "utf-8");
-        const data = JSON.parse(raw);
-        if (!data.clientToken || !data.fcmToken)
-            return null;
-        return data;
-    }
-    catch {
-        return null;
-    }
-}
-export function setLocationDevice(clientToken, fcmToken) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
-    fs.writeFileSync(LOCATION_FILE, JSON.stringify({ clientToken, fcmToken }, null, 2), "utf-8");
-}
-export function clearLocationDevice() {
-    try {
-        if (fs.existsSync(LOCATION_FILE))
-            fs.unlinkSync(LOCATION_FILE);
-    }
-    catch {
-        // ignore
-    }
-}
-//# sourceMappingURL=location-device.js.map