palmier 0.7.0 → 0.7.3

package/src/mcp-tools.ts

@@ -2,6 +2,7 @@ import { StringCodec, type NatsConnection } from "nats";
 import { registerPending } from "./pending-requests.js";
 import { getLocationDevice } from "./location-device.js";
 import { getNotifications } from "./notification-store.js";
+import { getSmsMessages } from "./sms-store.js";
 import type { HostConfig } from "./types.js";
 
 export class ToolError extends Error {
@@ -203,7 +204,442 @@ const deviceGeolocationTool: ToolDefinition = {
   },
 };
 
-export const agentTools: ToolDefinition[] = [notifyTool, requestInputTool, requestConfirmationTool, deviceGeolocationTool];
+const readContactsTool: ToolDefinition = {
+  name: "read-contacts",
+  description: [
+    "Read the contact list from the user's mobile device.",
+    "Blocks until the device responds (up to 30 seconds).",
+    'Response: `{"contacts": [{"id": ..., "name": ..., "phone": ...}]}` on success, or `{"error": "..."}` on failure.',
+  ],
+  inputSchema: {
+    type: "object",
+    properties: {},
+  },
+  async handler(_args, ctx) {
+    if (!ctx.nc) throw new ToolError("Not connected to server (NATS unavailable)", 503);
+
+    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" })),
+      { timeout: 5_000 },
+    );
+    const ack = JSON.parse(sc.decode(ackReply.data)) as { ok?: boolean; error?: string };
+    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}.contacts.${ctx.sessionId}`, { max: 1 });
+      const timer = setTimeout(() => {
+        sub.unsubscribe();
+        reject(new ToolError("Device did not respond within 30 seconds", 504));
+      }, 30_000);
+
+      (async () => {
+        for await (const msg of sub) {
+          clearTimeout(timer);
+          resolve(sc.decode(msg.data));
+        }
+      })();
+    });
+
+    const result = JSON.parse(await responsePromise);
+    if (result.error) return { error: result.error };
+    return result;
+  },
+};
+
+const createContactTool: ToolDefinition = {
+  name: "create-contact",
+  description: [
+    "Create a new contact on the user's mobile device.",
+    "Blocks until the device responds (up to 30 seconds).",
+    'Response: `{"ok": true}` on success, or `{"error": "..."}` on failure.',
+  ],
+  inputSchema: {
+    type: "object",
+    properties: {
+      name: { type: "string", description: "Contact display name" },
+      phone: { type: "string", description: "Phone number" },
+      email: { type: "string", description: "Email address" },
+    },
+    required: ["name"],
+  },
+  async handler(args, ctx) {
+    if (!ctx.nc) throw new ToolError("Not connected to server (NATS unavailable)", 503);
+
+    const { name, phone, email } = args as { name: string; phone?: string; email?: string };
+    if (!name) throw new ToolError("name is required", 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: "create", name, phone, email,
+      })),
+      { timeout: 5_000 },
+    );
+    const ack = JSON.parse(sc.decode(ackReply.data)) as { ok?: boolean; error?: string };
+    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}.contacts.${ctx.sessionId}`, { max: 1 });
+      const timer = setTimeout(() => {
+        sub.unsubscribe();
+        reject(new ToolError("Device did not respond within 30 seconds", 504));
+      }, 30_000);
+
+      (async () => {
+        for await (const msg of sub) {
+          clearTimeout(timer);
+          resolve(sc.decode(msg.data));
+        }
+      })();
+    });
+
+    const result = JSON.parse(await responsePromise);
+    if (result.error) return { error: result.error };
+    return result;
+  },
+};
+
+const readCalendarTool: ToolDefinition = {
+  name: "read-calendar",
+  description: [
+    "Read calendar events from the user's mobile device.",
+    "Blocks until the device responds (up to 30 seconds).",
+    "Pass startDate and endDate as Unix timestamps in milliseconds. Defaults to next 7 days.",
+    'Response: `{"events": [{"id": ..., "title": ..., "startTime": ..., "endTime": ..., "location": ..., "description": ..., "allDay": ..., "calendar": ...}]}` on success.',
+  ],
+  inputSchema: {
+    type: "object",
+    properties: {
+      startDate: { type: "number", description: "Start of range (Unix ms). Defaults to now." },
+      endDate: { type: "number", description: "End of range (Unix ms). Defaults to 7 days from start." },
+    },
+  },
+  async handler(args, ctx) {
+    if (!ctx.nc) throw new ToolError("Not connected to server (NATS unavailable)", 503);
+
+    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,
+        action: "read",
+        ...(startDate ? { startDate: String(startDate) } : {}),
+        ...(endDate ? { endDate: String(endDate) } : {}),
+      })),
+      { timeout: 5_000 },
+    );
+    const ack = JSON.parse(sc.decode(ackReply.data)) as { ok?: boolean; error?: string };
+    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}.calendar.${ctx.sessionId}`, { max: 1 });
+      const timer = setTimeout(() => {
+        sub.unsubscribe();
+        reject(new ToolError("Device did not respond within 30 seconds", 504));
+      }, 30_000);
+
+      (async () => {
+        for await (const msg of sub) {
+          clearTimeout(timer);
+          resolve(sc.decode(msg.data));
+        }
+      })();
+    });
+
+    const result = JSON.parse(await responsePromise);
+    if (result.error) return { error: result.error };
+    return result;
+  },
+};
+
+const createCalendarEventTool: ToolDefinition = {
+  name: "create-calendar-event",
+  description: [
+    "Create a calendar event on the user's mobile device.",
+    "Blocks until the device responds (up to 30 seconds).",
+    'Response: `{"ok": true}` on success, or `{"error": "..."}` on failure.',
+  ],
+  inputSchema: {
+    type: "object",
+    properties: {
+      title: { type: "string", description: "Event title" },
+      startTime: { type: "number", description: "Start time (Unix ms)" },
+      endTime: { type: "number", description: "End time (Unix ms)" },
+      location: { type: "string", description: "Event location" },
+      description: { type: "string", description: "Event description" },
+    },
+    required: ["title", "startTime", "endTime"],
+  },
+  async handler(args, ctx) {
+    if (!ctx.nc) throw new ToolError("Not connected to server (NATS unavailable)", 503);
+
+    const { title, startTime, endTime, location, description } = args as {
+      title: string; startTime: number; endTime: number; location?: string; description?: string;
+    };
+    if (!title || !startTime || !endTime) throw new ToolError("title, startTime, and endTime are required", 400);
+
+    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,
+        action: "create",
+        title, startTime: String(startTime), endTime: String(endTime),
+        ...(location ? { location } : {}),
+        ...(description ? { description } : {}),
+      })),
+      { timeout: 5_000 },
+    );
+    const ack = JSON.parse(sc.decode(ackReply.data)) as { ok?: boolean; error?: string };
+    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}.calendar.${ctx.sessionId}`, { max: 1 });
+      const timer = setTimeout(() => {
+        sub.unsubscribe();
+        reject(new ToolError("Device did not respond within 30 seconds", 504));
+      }, 30_000);
+
+      (async () => {
+        for await (const msg of sub) {
+          clearTimeout(timer);
+          resolve(sc.decode(msg.data));
+        }
+      })();
+    });
+
+    const result = JSON.parse(await responsePromise);
+    if (result.error) return { error: result.error };
+    return result;
+  },
+};
+
+const sendSmsTool: ToolDefinition = {
+  name: "send-sms",
+  description: [
+    "Send an SMS message from the user's mobile device.",
+    "Blocks until the device responds (up to 30 seconds).",
+    'Response: `{"ok": true}` on success, or `{"error": "..."}` on failure.',
+  ],
+  inputSchema: {
+    type: "object",
+    properties: {
+      to: { type: "string", description: "Recipient phone number" },
+      body: { type: "string", description: "Message text" },
+    },
+    required: ["to", "body"],
+  },
+  async handler(args, ctx) {
+    if (!ctx.nc) throw new ToolError("Not connected to server (NATS unavailable)", 503);
+
+    const { to, body } = args as { to: string; body: string };
+    if (!to || !body) throw new ToolError("to and body are required", 400);
+
+    const sc = StringCodec();
+
+    const ackReply = await ctx.nc.request(
+      `host.${ctx.config.hostId}.fcm.sms`,
+      sc.encode(JSON.stringify({
+        hostId: ctx.config.hostId, requestId: ctx.sessionId,
+        action: "send", to, body,
+      })),
+      { timeout: 5_000 },
+    );
+    const ack = JSON.parse(sc.decode(ackReply.data)) as { ok?: boolean; error?: string };
+    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}.sms.${ctx.sessionId}`, { max: 1 });
+      const timer = setTimeout(() => {
+        sub.unsubscribe();
+        reject(new ToolError("Device did not respond within 30 seconds", 504));
+      }, 30_000);
+
+      (async () => {
+        for await (const msg of sub) {
+          clearTimeout(timer);
+          resolve(sc.decode(msg.data));
+        }
+      })();
+    });
+
+    const result = JSON.parse(await responsePromise);
+    if (result.error) return { error: result.error };
+    return result;
+  },
+};
+
+const setAlarmTool: ToolDefinition = {
+  name: "set-alarm",
+  description: [
+    "Set an alarm on the user's mobile device.",
+    "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.",
+      },
+    },
+    required: ["hour", "minutes"],
+  },
+  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 sc = StringCodec();
+
+    const payload: Record<string, unknown> = {
+      hostId: ctx.config.hostId, requestId: ctx.sessionId,
+      action: "set", hour: String(hour), minutes: String(minutes),
+    };
+    if (label) payload.label = label;
+    if (days?.length) payload.days = days.join(",");
+
+    const ackReply = await ctx.nc.request(
+      `host.${ctx.config.hostId}.fcm.alarm`,
+      sc.encode(JSON.stringify(payload)),
+      { timeout: 5_000 },
+    );
+    const ack = JSON.parse(sc.decode(ackReply.data)) as { ok?: boolean; error?: string };
+    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 timer = setTimeout(() => {
+        sub.unsubscribe();
+        reject(new ToolError("Device did not respond within 30 seconds", 504));
+      }, 30_000);
+
+      (async () => {
+        for await (const msg of sub) {
+          clearTimeout(timer);
+          resolve(sc.decode(msg.data));
+        }
+      })();
+    });
+
+    const result = JSON.parse(await responsePromise);
+    if (result.error) return { error: result.error };
+    return result;
+  },
+};
+
+const readBatteryTool: ToolDefinition = {
+  name: "read-battery",
+  description: [
+    "Get the battery level and charging status of the user's mobile device.",
+    "Blocks until the device responds (up to 30 seconds).",
+    'Response: `{"level": 85, "charging": true}` on success, or `{"error": "..."}` on failure.',
+  ],
+  inputSchema: {
+    type: "object",
+    properties: {},
+  },
+  async handler(_args, ctx) {
+    if (!ctx.nc) throw new ToolError("Not connected to server (NATS unavailable)", 503);
+
+    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 })),
+      { timeout: 5_000 },
+    );
+    const ack = JSON.parse(sc.decode(ackReply.data)) as { ok?: boolean; error?: string };
+    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}.battery.${ctx.sessionId}`, { max: 1 });
+      const timer = setTimeout(() => {
+        sub.unsubscribe();
+        reject(new ToolError("Device did not respond within 30 seconds", 504));
+      }, 30_000);
+
+      (async () => {
+        for await (const msg of sub) {
+          clearTimeout(timer);
+          resolve(sc.decode(msg.data));
+        }
+      })();
+    });
+
+    const result = JSON.parse(await responsePromise);
+    if (result.error) return { error: result.error };
+    return result;
+  },
+};
+
+const setRingerModeTool: ToolDefinition = {
+  name: "set-ringer-mode",
+  description: [
+    "Set the phone's ringer mode. Requires Do Not Disturb access on the device.",
+    "Blocks until the device responds (up to 30 seconds).",
+    'Response: `{"ok": true, "mode": "silent"}` on success, or `{"error": "..."}` on failure.',
+  ],
+  inputSchema: {
+    type: "object",
+    properties: {
+      mode: { type: "string", description: "Ringer mode: 'normal', 'vibrate', or 'silent'" },
+    },
+    required: ["mode"],
+  },
+  async handler(args, ctx) {
+    if (!ctx.nc) throw new ToolError("Not connected to server (NATS unavailable)", 503);
+
+    const { mode } = args as { mode: string };
+    if (!["normal", "vibrate", "silent"].includes(mode)) throw new ToolError("mode must be 'normal', 'vibrate', or 'silent'", 400);
+
+    const sc = StringCodec();
+
+    const ackReply = await ctx.nc.request(
+      `host.${ctx.config.hostId}.fcm.ringer`,
+      sc.encode(JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.sessionId, mode })),
+      { timeout: 5_000 },
+    );
+    const ack = JSON.parse(sc.decode(ackReply.data)) as { ok?: boolean; error?: string };
+    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}.ringer.${ctx.sessionId}`, { max: 1 });
+      const timer = setTimeout(() => {
+        sub.unsubscribe();
+        reject(new ToolError("Device did not respond within 30 seconds", 504));
+      }, 30_000);
+
+      (async () => {
+        for await (const msg of sub) {
+          clearTimeout(timer);
+          resolve(sc.decode(msg.data));
+        }
+      })();
+    });
+
+    const result = JSON.parse(await responsePromise);
+    if (result.error) return { error: result.error };
+    return result;
+  },
+};
+
+export const agentTools: ToolDefinition[] = [notifyTool, requestInputTool, requestConfirmationTool, deviceGeolocationTool, readContactsTool, createContactTool, readCalendarTool, createCalendarEventTool, sendSmsTool, setAlarmTool, readBatteryTool, setRingerModeTool];
 export const agentToolMap = new Map<string, ToolDefinition>(agentTools.map((t) => [t.name, t]));
 
 // ── MCP Resources ─────────────────────────────────────────────────────
@@ -234,7 +670,19 @@ const deviceNotificationsResource: ResourceDefinition = {
   read: getNotifications,
 };
 
-export const agentResources: ResourceDefinition[] = [deviceNotificationsResource];
+const deviceSmsResource: ResourceDefinition = {
+  uri: "sms://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",
+  read: getSmsMessages,
+};
+
+export const agentResources: ResourceDefinition[] = [deviceNotificationsResource, deviceSmsResource];
 export const agentResourceMap = new Map<string, ResourceDefinition>(agentResources.map((r) => [r.uri, r]));
 
 /**
@@ -288,7 +736,7 @@ export function generateEndpointDocs(
 
   for (const resource of resources) {
     const [header, ...details] = resource.description;
-    lines.push(`**\`GET ${baseUrl}${resource.restPath}\`** — ${header}`);
+    lines.push(`**\`GET ${baseUrl}${resource.restPath}?taskId=${taskId}\`** — ${header}`);
     for (const detail of details) {
       lines.push(`- ${detail}`);
     }

package/src/sms-store.ts

@@ -0,0 +1,28 @@
+export interface SmsMessage {
+  id: string;
+  sender: string;
+  body: string;
+  timestamp: number;
+  receivedAt: number;
+}
+
+const MAX_MESSAGES = 50;
+const messages: SmsMessage[] = [];
+const listeners = new Set<() => void>();
+
+export function addSmsMessage(m: SmsMessage): void {
+  messages.push(m);
+  if (messages.length > MAX_MESSAGES) {
+    messages.shift();
+  }
+  for (const cb of listeners) cb();
+}
+
+export function getSmsMessages(): SmsMessage[] {
+  return [...messages];
+}
+
+export function onSmsChanged(cb: () => void): () => void {
+  listeners.add(cb);
+  return () => { listeners.delete(cb); };
+}

package/src/transports/http-transport.ts

@@ -10,6 +10,7 @@ import { agentToolMap, agentResources, ToolError, type ToolContext } from "../mc
 import { handleMcpRequest, getAgentName, getResourceSubscriptions } from "../mcp-handler.js";
 import { getTaskDir } from "../task.js";
 import { onNotificationsChanged } from "../notification-store.js";
+import { onSmsChanged } from "../sms-store.js";
 
 // ── Bundled PWA asset serving ───────────────────────────────────────────
 
@@ -124,6 +125,7 @@ export async function startHttpTransport(
 
   // Wire up resource change listeners
   onNotificationsChanged(() => broadcastResourceUpdated("notifications://device"));
+  onSmsChanged(() => broadcastResourceUpdated("sms://device"));
 
   // If a pairing code is provided, pre-register it
   if (pairingCode) {
@@ -262,7 +264,20 @@ export async function startHttpTransport(
     const matchedResource = req.method === "GET" && agentResources.find((r) => r.restPath === pathname);
     if (matchedResource) {
       if (!isLocalhost(req)) { sendJson(res, 403, { error: "localhost only" }); return; }
-      sendJson(res, 200, matchedResource.read());
+      const taskId = url.searchParams.get("taskId");
+      if (!taskId) {
+        sendJson(res, 400, { error: "taskId query parameter is required" });
+        return;
+      }
+      const taskDir = getTaskDir(config.projectRoot, taskId);
+      if (!fs.existsSync(taskDir)) {
+        sendJson(res, 404, { error: `Task not found: ${taskId}` });
+        return;
+      }
+      console.log(`[mcp] REST [${taskId.slice(0, 8)}] ${matchedResource.name}`);
+      const result = matchedResource.read();
+      console.log(`[mcp] REST [${taskId.slice(0, 8)}] ${matchedResource.name} done: ${JSON.stringify(result).slice(0, 200)}`);
+      sendJson(res, 200, result);
       return;
     }
 

package/test/agent-instructions.test.ts

@@ -141,7 +141,7 @@ describe("generateEndpointDocs", () => {
       "- Blocks until the device responds.",
       '- Response: `{"data": ...}` on success.',
       "",
-      "**`GET http://localhost:9966/mock-data`** — Get mock data from the device.",
+      "**`GET http://localhost:9966/mock-data?taskId=test-id`** — Get mock data from the device.",
       "- Response: JSON array of data objects.",
     ].join("\n");
     assert.equal(docs, expected);