palmier 0.7.2 → 0.7.4

package/src/mcp-tools.ts

@@ -1,7 +1,8 @@
 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";
 
 export class ToolError extends Error {
@@ -169,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 };
@@ -203,7 +204,460 @@ 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 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, fcmToken: device.fcmToken, 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 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);
+
+    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, fcmToken: device.fcmToken,
+        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 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, fcmToken: device.fcmToken,
+        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 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;
+    };
+    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, fcmToken: device.fcmToken,
+        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-message",
+  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 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);
+
+    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, fcmToken: device.fcmToken,
+        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 sendAlertTool: ToolDefinition = {
+  name: "send-alert",
+  description: [
+    "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: {
+      title: { type: "string", description: "Alert title" },
+      description: { type: "string", description: "Alert description/details" },
+    },
+    required: ["title"],
+  },
+  async handler(args, ctx) {
+    if (!ctx.nc) throw new ToolError("Not connected to server (NATS unavailable)", 503);
+
+    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, string> = {
+      hostId: ctx.config.hostId, requestId: ctx.sessionId, fcmToken: device.fcmToken,
+      title,
+    };
+    if (description) payload.description = description;
+
+    const ackReply = await ctx.nc.request(
+      `host.${ctx.config.hostId}.fcm.alert`,
+      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}.alert.${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 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, fcmToken: device.fcmToken })),
+      { 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 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);
+
+    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, fcmToken: device.fcmToken, 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, sendAlertTool, readBatteryTool, setRingerModeTool];
 export const agentToolMap = new Map<string, ToolDefinition>(agentTools.map((t) => [t.name, t]));
 
 // ── MCP Resources ─────────────────────────────────────────────────────
@@ -234,7 +688,19 @@ const deviceNotificationsResource: ResourceDefinition = {
   read: getNotifications,
 };
 
-export const agentResources: ResourceDefinition[] = [deviceNotificationsResource];
+const deviceSmsResource: ResourceDefinition = {
+  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-messages",
+  read: getSmsMessages,
+};
+
+export const agentResources: ResourceDefinition[] = [deviceNotificationsResource, deviceSmsResource];
 export const agentResourceMap = new Map<string, ResourceDefinition>(agentResources.map((r) => [r.uri, r]));
 
 /**
@@ -288,7 +754,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/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/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-messages://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);

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