palmier 1.1.16 → 1.1.18

package/README.md

@@ -45,15 +45,13 @@ Capability access is opt-in per device: each capability is gated behind an Andro
 
 Palmier runs as a background daemon (systemd on Linux, launchd on macOS, Task Scheduler on Windows). It invokes your agent CLIs directly, schedules tasks via native OS timers, and exposes an API that the PWA connects to — either directly over HTTP or remotely through a relay server. Agents can interact with the user's mobile device during execution — requesting input, sending push notifications and full-screen alarms, reading SMS/notifications, managing contacts and calendar, and more.
 
-### MCP Server
+### Agent Capabilities
 
-Palmier exposes an [MCP](https://modelcontextprotocol.io) server at `http://localhost:7256/mcp` (streamable HTTP transport). MCP-capable agents can register it to get tool and resource definitions automatically. The same tools and resources are also readily available if running agent tasks directly from Palmier app, without installing the MCP server.
+Every task Palmier runs gets these capabilities automatically. Their usage is written into the agent's instructions at launch, so no agent-side setup is needed.
 
-**MCP server URL:** `http://localhost:7256/mcp`
-
-**Available tools:**
-| Tool | Description |
-|------|-------------|
+**Actions:**
+| Capability | Description |
+|------------|-------------|
 | `notify` | Send a push notification to the user's device |
 | `request-input` | Request input from the user (blocks until response; aborting the prompt aborts the task) |
 | `request-choice` | Ask the user a question with a fixed set of options and return the one picked; a single option serves as a confirmation (blocks until response; aborting aborts the task) |
@@ -69,13 +67,11 @@ Palmier exposes an [MCP](https://modelcontextprotocol.io) server at `http://loca
 | `read-battery` | Get battery level and charging status |
 | `set-ringer-mode` | Set ringer mode (normal/vibrate/silent) |
 
-**Available resources:**
-| Resource | URI | Description |
-|----------|-----|-------------|
-| Device Notifications | `notifications://device` | Recent notifications from the user's Android device |
-| Device SMS | `sms-messages://device` | Recent SMS messages from the user's Android device |
-
-Resources support MCP subscriptions — clients can subscribe via `resources/subscribe` and receive real-time `notifications/resources/updated` events via the streamable HTTP transport when the resource changes.
+**Device data:**
+| Capability | Description |
+|------------|-------------|
+| Device Notifications | Recent notifications from the user's Android device |
+| Device SMS | Recent SMS messages from the user's Android device |
 
 All device tools work while the Palmier Android app is in the background — they communicate via FCM data messages which wake the app's service even when it's not in the foreground. Each host has one **linked device**: the phone the host uses for SMS, contacts, location, and other device capabilities. Choose it at pair time (the "Link the host to this device" checkbox) or later from the drawer. Each capability must be enabled and its Android permission granted via toggles in the linked device's drawer.
 
@@ -89,7 +85,7 @@ Agents run with the task's run directory (`~/palmier/tasks/<task-id>/<run-id>/`)
 ┌──────────────┐         HTTP          ┌──────────────────┐
 │              │◄──────────────────────│                  │
 │  Host Daemon │                       │   PWA (Browser)  │
-│  (MCP Server)│◄──────┐               │                  │
+│              │◄──────┐               │                  │
 └──┬────────┬──┘       │               └──────────────────┘
    │        │          │                        │
    ▼        ▼          │  NATS (TLS)            │ NATS (TLS)

package/dist/{mcp-tools.d.ts → agent-tools.d.ts}

@@ -8,9 +8,8 @@ export interface ToolContext {
     config: HostConfig;
     nc: NatsConnection | undefined;
     publishEvent: (id: string, payload: Record<string, unknown>) => Promise<void>;
-    sessionId: string;
-    agentName?: string;
-    abortTask: (taskId: string) => Promise<void>;
+    taskId: string;
+    abortTask: () => Promise<void>;
 }
 export interface ToolDefinition {
     name: string;
@@ -23,20 +22,14 @@ export declare const requestConfirmationTool: ToolDefinition;
 export declare const agentTools: ToolDefinition[];
 export declare const agentToolMap: Map<string, ToolDefinition>;
 export interface ResourceDefinition {
-    /** MCP resource URI (e.g. "notifications://device"). */
-    uri: string;
     /** Display name. */
     name: string;
     /** First line is the summary (used as REST endpoint header). Remaining lines become bullet points in docs. */
     description: string[];
-    mimeType: string;
     /** REST endpoint path (e.g. "/notifications"). Served as GET. */
     restPath: string;
     /** Return the current resource content. */
     read: () => unknown;
-    /** Register a listener for content changes. Returns an unsubscribe function. */
-    subscribe: (listener: () => void) => () => void;
 }
 export declare const agentResources: ResourceDefinition[];
-export declare const agentResourceMap: Map<string, ResourceDefinition>;
 export declare function generateEndpointDocs(port: number, taskId: string, tools?: ToolDefinition[], resources?: ResourceDefinition[]): string;

package/dist/{mcp-tools.js → agent-tools.js}

@@ -1,9 +1,8 @@
-import * as fs from "fs";
 import { StringCodec } from "nats";
 import { registerPending } from "./pending-requests.js";
 import { getLinkedDevice } from "./linked-device.js";
-import { getNotifications, onNotificationsChanged } from "./notification-store.js";
-import { getSmsMessages, onSmsChanged } from "./sms-store.js";
+import { getNotifications } from "./notification-store.js";
+import { getSmsMessages } from "./sms-store.js";
 import { getTaskDir, readHistory, spliceUserMessage } from "./task.js";
 import { lookupPassword, savePassword, normalizeOrigin } from "./password-store.js";
 import { fillPasswordInBrowser } from "./playwright-fill.js";
@@ -35,11 +34,7 @@ const notifyTool = {
         if (!ctx.nc)
             throw new ToolError("NATS not connected — push notifications require server mode", 503);
         const sc = StringCodec();
-        const payload = { hostId: ctx.config.hostId, title, body };
-        if (ctx.sessionId)
-            payload.session_id = ctx.sessionId;
-        if (ctx.agentName)
-            payload.agent_name = ctx.agentName;
+        const payload = { hostId: ctx.config.hostId, title, body, session_id: ctx.taskId };
         const subject = `host.${ctx.config.hostId}.push.send`;
         const reply = await ctx.nc.request(subject, sc.encode(JSON.stringify(payload)), { timeout: 15_000 });
         const result = JSON.parse(sc.decode(reply.data));
@@ -73,17 +68,15 @@ const requestInputTool = {
         const { description, questions } = args;
         if (!questions?.length)
             throw new ToolError("questions is required", 400);
-        const pendingPromise = registerPending(ctx.sessionId, "input", questions, {
-            session_id: ctx.sessionId,
-            session_name: ctx.agentName,
+        const pendingPromise = registerPending(ctx.taskId, "input", questions, {
+            session_id: ctx.taskId,
             description,
             input_questions: questions,
         });
         await ctx.publishEvent("_input", {
             event_type: "input-request",
             host_id: ctx.config.hostId,
-            session_id: ctx.sessionId,
-            session_name: ctx.agentName,
+            session_id: ctx.taskId,
             description,
             input_questions: questions,
         });
@@ -95,32 +88,22 @@ const requestInputTool = {
         if (aborted) {
             await ctx.publishEvent("_input", {
                 event_type: "input-resolved", host_id: ctx.config.hostId,
-                session_id: ctx.sessionId, status: "aborted",
+                session_id: ctx.taskId, status: "aborted",
             });
-            await abortSessionTask(ctx);
+            await ctx.abortTask();
             return { aborted: true };
         }
         await ctx.publishEvent("_input", {
             event_type: "input-resolved", host_id: ctx.config.hostId,
-            session_id: ctx.sessionId, status: "provided",
+            session_id: ctx.taskId, status: "provided",
         });
         return { values: response };
     },
 };
-/**
- * Splice the user's answer into the task run file so the conversation history
- * shows what the user typed, independent of whether the agent echoes it.
- * Only writes when sessionId resolves to a task with an active run (i.e. the
- * agent called via the REST endpoint with taskId); silently skips for pure
- * MCP-protocol sessions where sessionId is a random UUID.
- */
+/** Splice the user's answer into the run file so history shows it even if the agent never echoes it. */
 function recordUserResponseToRun(ctx, content) {
-    const taskId = ctx.sessionId;
-    if (!taskId)
-        return;
+    const taskId = ctx.taskId;
     const taskDir = getTaskDir(ctx.config.projectRoot, taskId);
-    if (!fs.existsSync(taskDir))
-        return;
     const { entries } = readHistory(ctx.config.projectRoot, { task_id: taskId, limit: 1 });
     const runId = entries[0]?.run_id;
     if (!runId)
@@ -138,13 +121,6 @@ function recordUserResponseToRun(ctx, content) {
         // Run file missing or unwritable — best-effort, do not fail the tool call.
     }
 }
-/** No-op for pure MCP-protocol sessions, whose sessionId is a random UUID rather than a task. */
-async function abortSessionTask(ctx) {
-    const taskId = ctx.sessionId;
-    if (!taskId || !fs.existsSync(getTaskDir(ctx.config.projectRoot, taskId)))
-        return;
-    await ctx.abortTask(taskId);
-}
 export const requestConfirmationTool = {
     name: "request-confirmation",
     description: [
@@ -163,16 +139,14 @@ export const requestConfirmationTool = {
         const { description } = args;
         if (!description)
             throw new ToolError("description is required", 400);
-        const pendingPromise = registerPending(ctx.sessionId, "confirmation", undefined, {
-            session_id: ctx.sessionId,
-            session_name: ctx.agentName,
+        const pendingPromise = registerPending(ctx.taskId, "confirmation", undefined, {
+            session_id: ctx.taskId,
             description,
         });
         await ctx.publishEvent("_confirm", {
             event_type: "confirm-request",
             host_id: ctx.config.hostId,
-            session_id: ctx.sessionId,
-            session_name: ctx.agentName,
+            session_id: ctx.taskId,
             description,
         });
         const response = await pendingPromise;
@@ -180,11 +154,11 @@ export const requestConfirmationTool = {
         await ctx.publishEvent("_confirm", {
             event_type: "confirm-resolved",
             host_id: ctx.config.hostId,
-            session_id: ctx.sessionId,
+            session_id: ctx.taskId,
             status: confirmed ? "confirmed" : "aborted",
         });
         if (!confirmed)
-            await abortSessionTask(ctx);
+            await ctx.abortTask();
         return { confirmed };
     },
 };
@@ -219,16 +193,14 @@ const requestChoiceTool = {
         }
         if (new Set(options).size !== options.length)
             throw new ToolError("options must be unique", 400);
-        const pendingPromise = registerPending(ctx.sessionId, "choice", options, {
-            session_id: ctx.sessionId,
-            session_name: ctx.agentName,
+        const pendingPromise = registerPending(ctx.taskId, "choice", options, {
+            session_id: ctx.taskId,
             description: question,
         });
         await ctx.publishEvent("_choice", {
             event_type: "choice-request",
             host_id: ctx.config.hostId,
-            session_id: ctx.sessionId,
-            session_name: ctx.agentName,
+            session_id: ctx.taskId,
             description: question,
             options,
         });
@@ -240,11 +212,11 @@ const requestChoiceTool = {
         await ctx.publishEvent("_choice", {
             event_type: "choice-resolved",
             host_id: ctx.config.hostId,
-            session_id: ctx.sessionId,
+            session_id: ctx.taskId,
             status: aborted ? "aborted" : "chosen",
         });
         if (aborted) {
-            await abortSessionTask(ctx);
+            await ctx.abortTask();
             return { aborted: true };
         }
         return { choice };
@@ -279,9 +251,8 @@ const fillPasswordTool = {
         if (password === undefined) {
             const question = `Password or PIN for ${username} on ${origin}`;
             const description = `Enter the password or PIN to sign in as ${username} on ${origin}.`;
-            const pendingPromise = registerPending(ctx.sessionId, "input", [question], {
-                session_id: ctx.sessionId,
-                session_name: ctx.agentName,
+            const pendingPromise = registerPending(ctx.taskId, "input", [question], {
+                session_id: ctx.taskId,
                 description,
                 input_questions: [question],
                 secret: true,
@@ -289,8 +260,7 @@ const fillPasswordTool = {
             await ctx.publishEvent("_input", {
                 event_type: "input-request",
                 host_id: ctx.config.hostId,
-                session_id: ctx.sessionId,
-                session_name: ctx.agentName,
+                session_id: ctx.taskId,
                 description,
                 input_questions: [question],
                 secret: true,
@@ -299,11 +269,11 @@ const fillPasswordTool = {
             const aborted = response.length === 1 && response[0] === "aborted";
             await ctx.publishEvent("_input", {
                 event_type: "input-resolved", host_id: ctx.config.hostId,
-                session_id: ctx.sessionId, status: aborted ? "aborted" : "provided",
+                session_id: ctx.taskId, status: aborted ? "aborted" : "provided",
             });
             // Never record the secret to the task run file (unlike request-input).
             if (aborted) {
-                await abortSessionTask(ctx);
+                await ctx.abortTask();
                 return { aborted: true };
             }
             password = response[0];
@@ -340,12 +310,12 @@ const deviceGeolocationTool = {
         if (!device)
             throw new ToolError("No linked device configured", 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: device.fcmToken })), { timeout: 5_000 });
+        const ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.geolocation`, sc.encode(JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken })), { timeout: 5_000 });
         const ack = JSON.parse(sc.decode(ackReply.data));
         if (ack.error)
             throw new ToolError(ack.error, 502);
         const locationPromise = new Promise((resolve, reject) => {
-            const sub = ctx.nc.subscribe(`host.${ctx.config.hostId}.geolocation.${ctx.sessionId}`, { max: 1 });
+            const sub = ctx.nc.subscribe(`host.${ctx.config.hostId}.geolocation.${ctx.taskId}`, { max: 1 });
             const timer = setTimeout(() => {
                 sub.unsubscribe();
                 reject(new ToolError("Device did not respond within 30 seconds", 504));
@@ -381,12 +351,12 @@ const readContactsTool = {
         if (!device)
             throw new ToolError("No linked device configured", 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 ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.contacts`, sc.encode(JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken, action: "read" })), { timeout: 5_000 });
         const ack = JSON.parse(sc.decode(ackReply.data));
         if (ack.error)
             throw new ToolError(ack.error, 502);
         const responsePromise = new Promise((resolve, reject) => {
-            const sub = ctx.nc.subscribe(`host.${ctx.config.hostId}.contacts.${ctx.sessionId}`, { max: 1 });
+            const sub = ctx.nc.subscribe(`host.${ctx.config.hostId}.contacts.${ctx.taskId}`, { max: 1 });
             const timer = setTimeout(() => {
                 sub.unsubscribe();
                 reject(new ToolError("Device did not respond within 30 seconds", 504));
@@ -431,14 +401,14 @@ const createContactTool = {
             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,
+            hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken,
             action: "create", name, phone, email,
         })), { timeout: 5_000 });
         const ack = JSON.parse(sc.decode(ackReply.data));
         if (ack.error)
             throw new ToolError(ack.error, 502);
         const responsePromise = new Promise((resolve, reject) => {
-            const sub = ctx.nc.subscribe(`host.${ctx.config.hostId}.contacts.${ctx.sessionId}`, { max: 1 });
+            const sub = ctx.nc.subscribe(`host.${ctx.config.hostId}.contacts.${ctx.taskId}`, { max: 1 });
             const timer = setTimeout(() => {
                 sub.unsubscribe();
                 reject(new ToolError("Device did not respond within 30 seconds", 504));
@@ -480,7 +450,7 @@ const readCalendarTool = {
         const { startDate, endDate } = args;
         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,
+            hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken,
             action: "read",
             ...(startDate ? { startDate: String(startDate) } : {}),
             ...(endDate ? { endDate: String(endDate) } : {}),
@@ -489,7 +459,7 @@ const readCalendarTool = {
         if (ack.error)
             throw new ToolError(ack.error, 502);
         const responsePromise = new Promise((resolve, reject) => {
-            const sub = ctx.nc.subscribe(`host.${ctx.config.hostId}.calendar.${ctx.sessionId}`, { max: 1 });
+            const sub = ctx.nc.subscribe(`host.${ctx.config.hostId}.calendar.${ctx.taskId}`, { max: 1 });
             const timer = setTimeout(() => {
                 sub.unsubscribe();
                 reject(new ToolError("Device did not respond within 30 seconds", 504));
@@ -536,7 +506,7 @@ const createCalendarEventTool = {
             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,
+            hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken,
             action: "create",
             title, startTime: String(startTime), endTime: String(endTime),
             ...(location ? { location } : {}),
@@ -546,7 +516,7 @@ const createCalendarEventTool = {
         if (ack.error)
             throw new ToolError(ack.error, 502);
         const responsePromise = new Promise((resolve, reject) => {
-            const sub = ctx.nc.subscribe(`host.${ctx.config.hostId}.calendar.${ctx.sessionId}`, { max: 1 });
+            const sub = ctx.nc.subscribe(`host.${ctx.config.hostId}.calendar.${ctx.taskId}`, { max: 1 });
             const timer = setTimeout(() => {
                 sub.unsubscribe();
                 reject(new ToolError("Device did not respond within 30 seconds", 504));
@@ -590,14 +560,14 @@ const sendSmsTool = {
             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,
+            hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken,
             action: "send", to, body,
         })), { timeout: 5_000 });
         const ack = JSON.parse(sc.decode(ackReply.data));
         if (ack.error)
             throw new ToolError(ack.error, 502);
         const responsePromise = new Promise((resolve, reject) => {
-            const sub = ctx.nc.subscribe(`host.${ctx.config.hostId}.sms.${ctx.sessionId}`, { max: 1 });
+            const sub = ctx.nc.subscribe(`host.${ctx.config.hostId}.sms.${ctx.taskId}`, { max: 1 });
             const timer = setTimeout(() => {
                 sub.unsubscribe();
                 reject(new ToolError("Device did not respond within 30 seconds", 504));
@@ -642,7 +612,7 @@ const sendAlarmTool = {
             throw new ToolError("title is required", 400);
         const sc = StringCodec();
         const payload = {
-            hostId: ctx.config.hostId, requestId: ctx.sessionId, fcmToken: device.fcmToken,
+            hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken,
             title,
         };
         if (description)
@@ -652,7 +622,7 @@ const sendAlarmTool = {
         if (ack.error)
             throw new ToolError(ack.error, 502);
         const responsePromise = new Promise((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}.alarm.${ctx.taskId}`, { max: 1 });
             const timer = setTimeout(() => {
                 sub.unsubscribe();
                 reject(new ToolError("Device did not respond within 30 seconds", 504));
@@ -688,12 +658,12 @@ const readBatteryTool = {
         if (!device)
             throw new ToolError("No linked device configured", 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 ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.battery`, sc.encode(JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken })), { timeout: 5_000 });
         const ack = JSON.parse(sc.decode(ackReply.data));
         if (ack.error)
             throw new ToolError(ack.error, 502);
         const responsePromise = new Promise((resolve, reject) => {
-            const sub = ctx.nc.subscribe(`host.${ctx.config.hostId}.battery.${ctx.sessionId}`, { max: 1 });
+            const sub = ctx.nc.subscribe(`host.${ctx.config.hostId}.battery.${ctx.taskId}`, { max: 1 });
             const timer = setTimeout(() => {
                 sub.unsubscribe();
                 reject(new ToolError("Device did not respond within 30 seconds", 504));
@@ -735,12 +705,12 @@ const setRingerModeTool = {
         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 ackReply = await ctx.nc.request(`host.${ctx.config.hostId}.fcm.ringer`, sc.encode(JSON.stringify({ hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken, mode })), { timeout: 5_000 });
         const ack = JSON.parse(sc.decode(ackReply.data));
         if (ack.error)
             throw new ToolError(ack.error, 502);
         const responsePromise = new Promise((resolve, reject) => {
-            const sub = ctx.nc.subscribe(`host.${ctx.config.hostId}.ringer.${ctx.sessionId}`, { max: 1 });
+            const sub = ctx.nc.subscribe(`host.${ctx.config.hostId}.ringer.${ctx.taskId}`, { max: 1 });
             const timer = setTimeout(() => {
                 sub.unsubscribe();
                 reject(new ToolError("Device did not respond within 30 seconds", 504));
@@ -787,7 +757,7 @@ const sendEmailTool = {
             throw new ToolError("to is required", 400);
         const sc = StringCodec();
         const payload = {
-            hostId: ctx.config.hostId, requestId: ctx.sessionId, fcmToken: device.fcmToken,
+            hostId: ctx.config.hostId, requestId: ctx.taskId, fcmToken: device.fcmToken,
             to,
         };
         if (subject)
@@ -803,7 +773,7 @@ const sendEmailTool = {
         if (ack.error)
             throw new ToolError(ack.error, 502);
         const responsePromise = new Promise((resolve, reject) => {
-            const sub = ctx.nc.subscribe(`host.${ctx.config.hostId}.email.${ctx.sessionId}`, { max: 1 });
+            const sub = ctx.nc.subscribe(`host.${ctx.config.hostId}.email.${ctx.taskId}`, { max: 1 });
             const timer = setTimeout(() => {
                 sub.unsubscribe();
                 reject(new ToolError("Device did not respond within 30 seconds", 504));
@@ -824,31 +794,24 @@ const sendEmailTool = {
 export const agentTools = [notifyTool, requestInputTool, requestChoiceTool, fillPasswordTool, deviceGeolocationTool, readContactsTool, createContactTool, readCalendarTool, createCalendarEventTool, sendSmsTool, sendEmailTool, sendAlarmTool, readBatteryTool, setRingerModeTool];
 export const agentToolMap = new Map(agentTools.map((t) => [t.name, t]));
 const deviceNotificationsResource = {
-    uri: "notifications://device",
     name: "Device Notifications",
     description: [
         "Get recent notifications from the user's Android device.",
         "Response: JSON array of notification objects with `id`, `packageName`, `appName`, `title`, `text`, `timestamp`.",
     ],
-    mimeType: "application/json",
     restPath: "/notifications",
     read: getNotifications,
-    subscribe: onNotificationsChanged,
 };
 const deviceSmsResource = {
-    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,
-    subscribe: onSmsChanged,
 };
 export const agentResources = [deviceNotificationsResource, deviceSmsResource];
-export const agentResourceMap = new Map(agentResources.map((r) => [r.uri, r]));
 export function generateEndpointDocs(port, taskId, tools = agentTools, resources = agentResources) {
     const baseUrl = `http://localhost:${port}`;
     const lines = [

package/dist/agents/agent.js

@@ -57,10 +57,11 @@ export function getNpmInstalledVersion(npmPackage) {
 const agentRegistry = {
     claude: claudeAgent,
     codex: codexAgent,
-    openclaw: openClawAgent,
+    grok: grokAgent,
     copilot: copilotAgent,
-    qwen: qwenAgent,
     kimi: kimiAgent,
+    qoder: qoderAgent,
+    qwen: qwenAgent,
     droid: droidAgent,
     goose: gooseAgent,
     opencode: openCodeAgent,
@@ -69,9 +70,8 @@ const agentRegistry = {
     cursor: cursorAgent,
     kiro: kiroAgent,
     cline: clineAgent,
-    qoder: qoderAgent,
+    openclaw: openClawAgent,
     hermes: hermesAgent,
-    grok: grokAgent,
 };
 const TIER_ONE_ORDER = ["claude", "codex", "copilot"];
 export function listInstallableAgents() {

package/dist/agents/shared-prompt.js

@@ -2,7 +2,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
 import { loadConfig } from "../config.js";
-import { generateEndpointDocs } from "../mcp-tools.js";
+import { generateEndpointDocs } from "../agent-tools.js";
 import { getAgent } from "./agent.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const AGENT_INSTRUCTIONS_TEMPLATE = fs.readFileSync(path.join(__dirname, "agent-instructions.md"), "utf-8");

package/dist/nats-client.js

@@ -7,6 +7,5 @@ export async function connectNats(config) {
         servers: config.natsUrl,
         authenticator: jwtAuthenticator(config.natsJwt, new TextEncoder().encode(config.natsNkeySeed)),
     });
-    // Do not log — it would pollute stdout for the MCP server.
     return nc;
 }

package/dist/notification-store.d.ts

@@ -9,4 +9,3 @@ export interface DeviceNotification {
 }
 export declare function addNotification(n: DeviceNotification): void;
 export declare function getNotifications(): DeviceNotification[];
-export declare function onNotificationsChanged(cb: () => void): () => void;

package/dist/notification-store.js

@@ -1,18 +1,11 @@
 const MAX_NOTIFICATIONS = 50;
 const notifications = [];
-const listeners = new Set();
 export function addNotification(n) {
     notifications.push(n);
     if (notifications.length > MAX_NOTIFICATIONS) {
         notifications.shift();
     }
-    for (const cb of listeners)
-        cb();
 }
 export function getNotifications() {
     return [...notifications];
 }
-export function onNotificationsChanged(cb) {
-    listeners.add(cb);
-    return () => { listeners.delete(cb); };
-}

package/dist/pending-requests.d.ts

@@ -1,9 +1,8 @@
 import type { RequiredPermission } from "./types.js";
 export interface PendingRequestMeta {
-    /** Doubles as task_id for permission-type entries (the key the task uses). */
+    /** The task the request belongs to. */
     session_id?: string;
-    /** Human-readable label for whoever opened the prompt — agent name for
-     *  confirm/input/choice, task name for permission. */
+    /** Task name, set for permission requests. */
     session_name?: string;
     description?: string;
     input_questions?: string[];
@@ -19,9 +18,8 @@ export interface PendingRequest {
     meta?: PendingRequestMeta;
 }
 /**
- * Key is sessionId for confirmation/input/choice, taskId for permission. Only one
- * pending request per key at a time. `meta` is surfaced via host.info so a
- * freshly-connected PWA can render the modal without replaying events.
+ * Keyed by taskId. Only one pending request per key at a time. `meta` is surfaced
+ * via host.info so a freshly-connected PWA can render the modal without replaying events.
  */
 export declare function registerPending(key: string, type: PendingRequest["type"], params?: PendingRequest["params"], meta?: PendingRequestMeta): Promise<string[]>;
 export declare function resolvePending(key: string, value: string[]): boolean;

package/dist/pending-requests.js

@@ -1,8 +1,7 @@
 const pending = new Map();
 /**
- * Key is sessionId for confirmation/input/choice, taskId for permission. Only one
- * pending request per key at a time. `meta` is surfaced via host.info so a
- * freshly-connected PWA can render the modal without replaying events.
+ * Keyed by taskId. Only one pending request per key at a time. `meta` is surfaced
+ * via host.info so a freshly-connected PWA can render the modal without replaying events.
  */
 export function registerPending(key, type, params, meta) {
     if (pending.has(key)) {

package/dist/sms-store.d.ts

@@ -7,4 +7,3 @@ export interface SmsMessage {
 }
 export declare function addSmsMessage(m: SmsMessage): void;
 export declare function getSmsMessages(): SmsMessage[];
-export declare function onSmsChanged(cb: () => void): () => void;

package/dist/sms-store.js

@@ -1,18 +1,11 @@
 const MAX_MESSAGES = 50;
 const messages = [];
-const listeners = new Set();
 export function addSmsMessage(m) {
     messages.push(m);
     if (messages.length > MAX_MESSAGES) {
         messages.shift();
     }
-    for (const cb of listeners)
-        cb();
 }
 export function getSmsMessages() {
     return [...messages];
 }
-export function onSmsChanged(cb) {
-    listeners.add(cb);
-    return () => { listeners.delete(cb); };
-}

package/dist/transports/http-transport.js

@@ -7,8 +7,7 @@ import { registerPending } from "../pending-requests.js";
 import * as fs from "node:fs";
 import { saveConfig } from "../config.js";
 import { detectDefaultInterface } from "../network.js";
-import { agentToolMap, agentResources, requestConfirmationTool, ToolError } from "../mcp-tools.js";
-import { handleMcpRequest, getAgentName, getResourceSubscriptions } from "../mcp-handler.js";
+import { agentToolMap, agentResources, requestConfirmationTool, ToolError } from "../agent-tools.js";
 import { getTaskDir } from "../task.js";
 import { popEvent } from "../event-queues.js";
 const assetCache = new Map();
@@ -64,29 +63,9 @@ async function persistDefaultInterface(config) {
 }
 export async function startHttpTransport(config, handleRpc, port, nc, pairingCode, onReady) {
     const sseClients = new Set();
-    const mcpStreams = new Map();
     // Always bind 0.0.0.0 so other devices on the LAN can reach /rpc and /health.
     // The web UI, /pair, and /events are individually gated to loopback.
     const bindAddress = "0.0.0.0";
-    /** Push notifications/resources/updated to all MCP clients subscribed to the given URI. */
-    function broadcastResourceUpdated(uri) {
-        const subs = getResourceSubscriptions();
-        for (const [sessionId, uris] of subs) {
-            if (!uris.has(uri))
-                continue;
-            const stream = mcpStreams.get(sessionId);
-            if (!stream)
-                continue;
-            stream.write(`data: ${JSON.stringify({
-                jsonrpc: "2.0",
-                method: "notifications/resources/updated",
-                params: { uri },
-            })}\n\n`);
-        }
-    }
-    for (const resource of agentResources) {
-        resource.subscribe(() => broadcastResourceUpdated(resource.uri));
-    }
     if (pairingCode) {
         const EXPIRY_MS = 24 * 60 * 60 * 1000;
         const timer = setTimeout(() => { pendingPairs.delete(pairingCode); }, EXPIRY_MS);
@@ -134,10 +113,10 @@ export async function startHttpTransport(config, handleRpc, port, nc, pairingCod
         }
         broadcastSseEvent({ task_id: taskId, ...payload });
     }
-    function makeToolContext(sessionId) {
+    function makeToolContext(taskId) {
         return {
-            config, nc, publishEvent, sessionId, agentName: getAgentName(sessionId),
-            abortTask: async (taskId) => { await handleRpc({ method: "task.abort", params: { id: taskId }, localhost: true }); },
+            config, nc, publishEvent, taskId,
+            abortTask: async () => { await handleRpc({ method: "task.abort", params: { id: taskId }, localhost: true }); },
         };
     }
     const server = http.createServer(async (req, res) => {
@@ -151,44 +130,6 @@ export async function startHttpTransport(config, handleRpc, port, nc, pairingCod
             res.end(JSON.stringify({ ok: true, hostId: config.hostId }));
             return;
         }
-        if (req.method === "POST" && pathname === "/mcp") {
-            if (!isLocalhost(req)) {
-                sendJson(res, 403, { error: "localhost only" });
-                return;
-            }
-            try {
-                const body = await readBody(req);
-                const sessionId = req.headers["mcp-session-id"];
-                const ctx = makeToolContext(sessionId ?? "");
-                const result = await handleMcpRequest(body, sessionId, ctx);
-                if (result.sessionId) {
-                    res.setHeader("Mcp-Session-Id", result.sessionId);
-                }
-                if (result.stream && sessionId) {
-                    // Keep the response open as SSE for server-initiated notifications.
-                    res.writeHead(200, {
-                        "Content-Type": "text/event-stream",
-                        "Cache-Control": "no-cache",
-                        "Connection": "keep-alive",
-                    });
-                    res.write(`data: ${JSON.stringify(result.body)}\n\n`);
-                    mcpStreams.set(sessionId, res);
-                    const heartbeat = setInterval(() => { res.write(":heartbeat\n\n"); }, 15_000);
-                    req.on("close", () => {
-                        clearInterval(heartbeat);
-                        mcpStreams.delete(sessionId);
-                        getResourceSubscriptions().delete(sessionId);
-                    });
-                }
-                else {
-                    sendJson(res, 200, result.body);
-                }
-            }
-            catch (err) {
-                sendJson(res, 500, { error: String(err) });
-            }
-            return;
-        }
         const tool = agentToolMap.get(pathname.slice(1))
             ?? (pathname === `/${requestConfirmationTool.name}` ? requestConfirmationTool : undefined);
         if (req.method === "POST" && tool) {
@@ -210,14 +151,14 @@ export async function startHttpTransport(config, handleRpc, port, nc, pairingCod
                 const body = await readBody(req);
                 const args = body.trim() ? JSON.parse(body) : {};
                 const ctx = makeToolContext(taskId);
-                console.log(`[mcp] REST [${taskId.slice(0, 8)}] ${tool.name}`);
+                console.log(`[tool] [${taskId.slice(0, 8)}] ${tool.name}`);
                 const result = await tool.handler(args, ctx);
-                console.log(`[mcp] REST [${taskId.slice(0, 8)}] ${tool.name} done:`, JSON.stringify(result).slice(0, 200));
+                console.log(`[tool] [${taskId.slice(0, 8)}] ${tool.name} done:`, JSON.stringify(result).slice(0, 200));
                 sendJson(res, 200, result);
             }
             catch (err) {
                 const status = err instanceof ToolError ? err.statusCode : 500;
-                console.error(`[mcp] REST ${tool.name} error:`, err.message ?? String(err));
+                console.error(`[tool] ${tool.name} error:`, err.message ?? String(err));
                 sendJson(res, status, { error: err.message ?? String(err) });
             }
             return;
@@ -238,9 +179,9 @@ export async function startHttpTransport(config, handleRpc, port, nc, pairingCod
                 sendJson(res, 404, { error: `Task not found: ${taskId}` });
                 return;
             }
-            console.log(`[mcp] REST [${taskId.slice(0, 8)}] ${matchedResource.name}`);
+            console.log(`[resource] [${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)}`);
+            console.log(`[resource] [${taskId.slice(0, 8)}] ${matchedResource.name} done: ${JSON.stringify(result).slice(0, 200)}`);
             sendJson(res, 200, result);
             return;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "palmier",
-  "version": "1.1.16",
+  "version": "1.1.18",
   "description": "Palmier host CLI - provisions, executes tasks, and serves NATS RPC",
   "license": "Apache-2.0",
   "author": "Hongxu Cai",

package/dist/mcp-handler.d.ts

@@ -1,10 +0,0 @@
-import { type ToolContext } from "./mcp-tools.js";
-export interface McpResponse {
-    body: object;
-    sessionId?: string;
-    /** If true, the HTTP transport should keep the response open as an SSE stream for server-initiated notifications. */
-    stream?: boolean;
-}
-export declare function getResourceSubscriptions(): Map<string, Set<string>>;
-export declare function getAgentName(sessionId: string): string | undefined;
-export declare function handleMcpRequest(body: string, sessionId: string | undefined, ctx: ToolContext): Promise<McpResponse>;

package/dist/mcp-handler.js

@@ -1,167 +0,0 @@
-import { randomUUID } from "crypto";
-import { agentTools, agentToolMap, agentResources, agentResourceMap, ToolError } from "./mcp-tools.js";
-/** sessionId → subscribed resource URIs */
-const resourceSubscriptions = new Map();
-export function getResourceSubscriptions() {
-    return resourceSubscriptions;
-}
-const SESSION_TTL_MS = 24 * 60 * 60 * 1000;
-const sessionAgents = new Map();
-export function getAgentName(sessionId) {
-    const entry = sessionAgents.get(sessionId);
-    if (!entry)
-        return undefined;
-    if (Date.now() > entry.expiresAt) {
-        sessionAgents.delete(sessionId);
-        return undefined;
-    }
-    return entry.agentName;
-}
-function pruneExpiredSessions() {
-    const now = Date.now();
-    for (const [id, entry] of sessionAgents) {
-        if (now > entry.expiresAt) {
-            sessionAgents.delete(id);
-            resourceSubscriptions.delete(id);
-        }
-    }
-}
-function rpcError(id, code, message) {
-    return { jsonrpc: "2.0", id, error: { code, message } };
-}
-function rpcResult(id, result) {
-    return { jsonrpc: "2.0", id, result };
-}
-export async function handleMcpRequest(body, sessionId, ctx) {
-    let req;
-    try {
-        req = JSON.parse(body);
-    }
-    catch {
-        return { body: rpcError(null, -32700, "Parse error") };
-    }
-    const id = req.id ?? null;
-    if (req.jsonrpc !== "2.0") {
-        return { body: rpcError(id, -32600, "Invalid Request: missing jsonrpc 2.0") };
-    }
-    const agent = sessionId ? getAgentName(sessionId) : undefined;
-    const sid = sessionId?.slice(0, 8) ?? "none";
-    const logPrefix = agent ? `[mcp] [${sid}] [${agent}]` : `[mcp] [${sid}]`;
-    console.log(`${logPrefix} ${req.method}${req.method === "tools/call" ? ` → ${req.params?.name}` : ""}`);
-    switch (req.method) {
-        case "initialize": {
-            const newSessionId = randomUUID();
-            const clientInfo = req.params?.clientInfo;
-            const agentName = clientInfo
-                ? `${clientInfo.name || "unknown"}${clientInfo.version ? ` ${clientInfo.version}` : ""}`
-                : undefined;
-            if (agentName) {
-                sessionAgents.set(newSessionId, { agentName, expiresAt: Date.now() + SESSION_TTL_MS });
-                pruneExpiredSessions();
-            }
-            console.log(`[mcp] [${newSessionId.slice(0, 8)}] Session initialized${agentName ? ` (${agentName})` : ""}`);
-            return {
-                body: rpcResult(id, {
-                    protocolVersion: "2025-03-26",
-                    capabilities: { tools: {}, resources: { subscribe: true } },
-                    serverInfo: { name: "palmier", version: "1.0.0" },
-                }),
-                sessionId: newSessionId,
-            };
-        }
-        case "tools/list": {
-            return {
-                body: rpcResult(id, {
-                    tools: agentTools.map((t) => ({
-                        name: t.name,
-                        description: t.description.join(" "),
-                        inputSchema: t.inputSchema,
-                    })),
-                }),
-            };
-        }
-        case "tools/call": {
-            const name = req.params?.name;
-            const args = (req.params?.arguments ?? {});
-            if (!name)
-                return { body: rpcError(id, -32602, "Missing params.name") };
-            const tool = agentToolMap.get(name);
-            if (!tool)
-                return { body: rpcError(id, -32602, `Unknown tool: ${name}`) };
-            try {
-                const result = await tool.handler(args, ctx);
-                console.log(`${logPrefix} tools/call ${name} done:`, JSON.stringify(result).slice(0, 200));
-                return {
-                    body: rpcResult(id, {
-                        content: [{ type: "text", text: JSON.stringify(result) }],
-                    }),
-                };
-            }
-            catch (err) {
-                const message = err instanceof ToolError ? err.message : String(err);
-                console.error(`${logPrefix} tools/call ${name} error:`, message);
-                return {
-                    body: rpcResult(id, {
-                        content: [{ type: "text", text: JSON.stringify({ error: message }) }],
-                        isError: true,
-                    }),
-                };
-            }
-        }
-        case "resources/list": {
-            return {
-                body: rpcResult(id, {
-                    resources: agentResources.map((r) => ({
-                        uri: r.uri,
-                        name: r.name,
-                        description: r.description[0],
-                        mimeType: r.mimeType,
-                    })),
-                }),
-            };
-        }
-        case "resources/read": {
-            const uri = req.params?.uri;
-            const resource = agentResourceMap.get(uri);
-            if (!resource) {
-                return { body: rpcError(id, -32602, `Unknown resource: ${uri}`) };
-            }
-            console.log(`${logPrefix} resources/read ${uri}`);
-            const content = resource.read();
-            console.log(`${logPrefix} resources/read ${uri} done: ${JSON.stringify(content).slice(0, 200)}`);
-            return {
-                body: rpcResult(id, {
-                    contents: [{
-                            uri: resource.uri,
-                            mimeType: resource.mimeType,
-                            text: JSON.stringify(content),
-                        }],
-                }),
-            };
-        }
-        case "resources/subscribe": {
-            const uri = req.params?.uri;
-            if (!agentResourceMap.has(uri)) {
-                return { body: rpcError(id, -32602, `Unknown resource: ${uri}`) };
-            }
-            if (!sessionId) {
-                return { body: rpcError(id, -32600, "Session required for subscriptions") };
-            }
-            if (!resourceSubscriptions.has(sessionId)) {
-                resourceSubscriptions.set(sessionId, new Set());
-            }
-            resourceSubscriptions.get(sessionId).add(uri);
-            return { body: rpcResult(id, {}), stream: true };
-        }
-        case "resources/unsubscribe": {
-            const uri = req.params?.uri;
-            if (sessionId) {
-                resourceSubscriptions.get(sessionId)?.delete(uri);
-            }
-            return { body: rpcResult(id, {}) };
-        }
-        default:
-            console.warn(`${logPrefix} Unknown method: ${req.method}`);
-            return { body: rpcError(id, -32601, `Method not found: ${req.method}`) };
-    }
-}