palmier 0.7.3 → 0.7.4

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,7 +163,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
     switch (request.method) {
       case "task.list": {
         const tasks = listTasks(config.projectRoot);
-        const locDevice = getLocationDevice();
+        const locDevice = getCapabilityDevice("location");
         return {
           tasks: tasks.map((task) => flattenTask(task)),
           agents: config.agents ?? [],
@@ -652,12 +652,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