palmier 0.7.6 → 0.7.7

package/src/commands/run.ts

@@ -67,7 +67,7 @@ async function invokeAgentWithRetries(
     );
     const result = await spawnCommand(command, args, {
       cwd: getRunDir(ctx.taskDir, ctx.runId),
-      env: { ...ctx.guiEnv, ...agentEnv, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId), PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 9966) },
+      env: { ...ctx.guiEnv, ...agentEnv, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId), PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 7256) },
       echoStdout: true,
       resolveOnFailure: true,
       stdin,
@@ -321,7 +321,7 @@ async function runCommandTriggeredMode(
 
   const child = spawnStreamingCommand(commandStr, {
     cwd: getRunDir(ctx.taskDir, ctx.runId),
-    env: { ...ctx.guiEnv, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId), PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 9966) },
+    env: { ...ctx.guiEnv, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId), PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 7256) },
   });
 
   let linesProcessed = 0;
@@ -483,7 +483,7 @@ async function requestPermission(
   taskDir: string,
   requiredPermissions: RequiredPermission[],
 ): Promise<"granted" | "granted_all" | "aborted"> {
-  const port = config.httpPort ?? 9966;
+  const port = config.httpPort ?? 7256;
   const res = await fetch(`http://localhost:${port}/request-permission`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
@@ -511,7 +511,7 @@ async function requestConfirmation(
   task: ParsedTask,
   taskDir: string,
 ): Promise<boolean> {
-  const port = config.httpPort ?? 9966;
+  const port = config.httpPort ?? 7256;
   const res = await fetch(`http://localhost:${port}/request-confirmation?taskId=${encodeURIComponent(task.frontmatter.id)}`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },

package/src/commands/serve.ts

@@ -127,7 +127,7 @@ export async function serveCommand(): Promise<void> {
   }, POLL_INTERVAL_MS);
 
   const handleRpc = createRpcHandler(config, nc);
-  const httpPort = config.httpPort ?? 9966;
+  const httpPort = config.httpPort ?? 7256;
 
   // Start NATS transport (loops forever, fire-and-forget)
   if (nc) {

package/src/config.ts

@@ -25,8 +25,8 @@ export function loadConfig(): HostConfig {
     throw new Error("Invalid host config: missing hostId");
   }
 
-  if (!config.natsUrl || !config.natsToken) {
-    throw new Error("Invalid host config: missing natsUrl or natsToken");
+  if (!config.natsUrl || !config.natsJwt || !config.natsNkeySeed) {
+    throw new Error("Invalid host config: missing NATS JWT credentials. Re-run palmier init.");
   }
 
   return config;

package/src/device-capabilities.ts

@@ -17,6 +17,7 @@ export type DeviceCapability =
   | "calendar"
   | "alert"
   | "battery"
+  | "email"
   | "dnd";
 
 type CapabilityMap = Partial<Record<DeviceCapability, RegisteredDevice>>;

package/src/events.ts

@@ -23,7 +23,7 @@ export async function publishHostEvent(
   }
 
   const config = loadConfig();
-  const port = config.httpPort ?? 9966;
+  const port = config.httpPort ?? 7256;
   try {
     await fetch(`http://localhost:${port}/event`, {
       method: "POST",

package/src/mcp-tools.ts

@@ -657,7 +657,74 @@ const setRingerModeTool: ToolDefinition = {
   },
 };
 
-export const agentTools: ToolDefinition[] = [notifyTool, requestInputTool, requestConfirmationTool, deviceGeolocationTool, readContactsTool, createContactTool, readCalendarTool, createCalendarEventTool, sendSmsTool, sendAlertTool, readBatteryTool, setRingerModeTool];
+const sendEmailTool: ToolDefinition = {
+  name: "send-email",
+  description: [
+    "Send an email from the user's mobile device.",
+    "When you need to send an email, use this tool. The email app opens on the device with the draft pre-filled for the user to review and send.",
+    'Response: `{"ok": true}` on success, or `{"error": "..."}` on failure.',
+  ],
+  inputSchema: {
+    type: "object",
+    properties: {
+      to: { type: "string", description: "Recipient email address" },
+      subject: { type: "string", description: "Email subject" },
+      body: { type: "string", description: "Email body text" },
+      cc: { type: "string", description: "CC recipient(s)" },
+      bcc: { type: "string", description: "BCC recipient(s)" },
+    },
+    required: ["to"],
+  },
+  async handler(args, ctx) {
+    if (!ctx.nc) throw new ToolError("Not connected to server (NATS unavailable)", 503);
+
+    const device = getCapabilityDevice("email");
+    if (!device) throw new ToolError("No device has email access enabled", 400);
+
+    const { to, subject, body, cc, bcc } = args as { to: string; subject?: string; body?: string; cc?: string; bcc?: string };
+    if (!to) throw new ToolError("to is required", 400);
+
+    const sc = StringCodec();
+
+    const payload: Record<string, string> = {
+      hostId: ctx.config.hostId, requestId: ctx.sessionId, fcmToken: device.fcmToken,
+      to,
+    };
+    if (subject) payload.subject = subject;
+    if (body) payload.body = body;
+    if (cc) payload.cc = cc;
+    if (bcc) payload.bcc = bcc;
+
+    const ackReply = await ctx.nc.request(
+      `host.${ctx.config.hostId}.fcm.email`,
+      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}.email.${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, sendEmailTool, sendAlertTool, readBatteryTool, setRingerModeTool];
 export const agentToolMap = new Map<string, ToolDefinition>(agentTools.map((t) => [t.name, t]));
 
 // ── MCP Resources ─────────────────────────────────────────────────────

package/src/nats-client.ts

@@ -1,13 +1,20 @@
-import { connect, type NatsConnection } from "nats";
+import { connect, jwtAuthenticator, type NatsConnection } from "nats";
 import type { HostConfig } from "./types.js";
 
 /**
- * Connect to NATS using the host config's TCP URL and token auth.
+ * Connect to NATS using the host config's JWT credentials.
  */
 export async function connectNats(config: HostConfig): Promise<NatsConnection> {
+  if (!config.natsJwt || !config.natsNkeySeed) {
+    throw new Error("NATS JWT credentials not configured. Re-run palmier init.");
+  }
+
   const nc = await connect({
     servers: config.natsUrl,
-    token: config.natsToken,
+    authenticator: jwtAuthenticator(
+      config.natsJwt,
+      new TextEncoder().encode(config.natsNkeySeed),
+    ),
   });
 
   // Do not log anything as that will pollute stdout for mcp server.

package/src/types.ts

@@ -4,12 +4,13 @@ export interface HostConfig {
 
   natsUrl?: string;
   natsWsUrl?: string;
-  natsToken?: string;
+  natsJwt?: string;
+  natsNkeySeed?: string;
 
   // Detected agent CLIs
   agents?: Array<{ key: string; label: string }>;
 
-  // HTTP server port (default 9966)
+  // HTTP server port (default 7256)
   httpPort?: number;
   // Whether to accept non-localhost HTTP connections
   lanEnabled?: boolean;

package/test/agent-instructions.test.ts

@@ -66,7 +66,7 @@ const mockResources: ResourceDefinition[] = [
 /** Minimal replica of getAgentInstructions that doesn't need host.json */
 function buildInstructions(taskId: string, opts?: { skipPermissions?: boolean }): string {
   let instructions = template
-    .replace(/\{\{ENDPOINT_DOCS\}\}/g, generateEndpointDocs(9966, taskId, mockTools, mockResources))
+    .replace(/\{\{ENDPOINT_DOCS\}\}/g, generateEndpointDocs(7256, taskId, mockTools, mockResources))
     .replace(/\{\{TASK_DESCRIPTION\}\}/g, "Test task prompt");
   if (opts?.skipPermissions) {
     instructions = instructions.replace(/## Permissions\r?\n[\s\S]*?(?=## |\r?\n---)/m, "");
@@ -107,7 +107,7 @@ describe("getAgentInstructions", () => {
 
   it("includes port in endpoint URL", () => {
     const result = buildInstructions("test");
-    assert.match(result, /localhost:9966/);
+    assert.match(result, /localhost:7256/);
   });
 
   it("includes task description", () => {
@@ -119,13 +119,13 @@ describe("getAgentInstructions", () => {
 
 
 describe("generateEndpointDocs", () => {
-  const docs = generateEndpointDocs(9966, "test-id", mockTools, mockResources);
+  const docs = generateEndpointDocs(7256, "test-id", mockTools, mockResources);
 
   it("matches expected full output", () => {
     const expected = [
       "The following HTTP endpoints are available during task execution. Use curl to call them.",
       "",
-      "**`POST http://localhost:9966/mock-action?taskId=test-id`** — Perform a mock action.",
+      "**`POST http://localhost:7256/mock-action?taskId=test-id`** — Perform a mock action.",
       "```json",
       '{"title":"...","detail":"..."}',
       "```",
@@ -133,7 +133,7 @@ describe("generateEndpointDocs", () => {
       "- `detail` (optional, string): Optional detail",
       '- Response: `{"ok": true}` on success.',
       "",
-      "**`POST http://localhost:9966/mock-query?taskId=test-id`** — Query mock data from the device.",
+      "**`POST http://localhost:7256/mock-query?taskId=test-id`** — Query mock data from the device.",
       "```json",
       '{"tags":["..."]}',
       "```",
@@ -141,7 +141,7 @@ describe("generateEndpointDocs", () => {
       "- Blocks until the device responds.",
       '- Response: `{"data": ...}` on success.',
       "",
-      "**`GET http://localhost:9966/mock-data?taskId=test-id`** — Get mock data from the device.",
+      "**`GET http://localhost:7256/mock-data?taskId=test-id`** — Get mock data from the device.",
       "- Response: JSON array of data objects.",
     ].join("\n");
     assert.equal(docs, expected);
@@ -149,7 +149,7 @@ describe("generateEndpointDocs", () => {
 
   it("generates docs for all provided tools", () => {
     for (const tool of mockTools) {
-      assert.match(docs, new RegExp(`POST http://localhost:9966/${tool.name}\\?taskId=`), `Missing endpoint for ${tool.name}`);
+      assert.match(docs, new RegExp(`POST http://localhost:7256/${tool.name}\\?taskId=`), `Missing endpoint for ${tool.name}`);
     }
   });
 
@@ -162,7 +162,7 @@ describe("generateEndpointDocs", () => {
   });
 
   it("includes port in the header", () => {
-    assert.match(docs, /localhost:9966/);
+    assert.match(docs, /localhost:7256/);
   });
 
   it("includes task ID in query parameters", () => {
@@ -194,7 +194,7 @@ describe("generateEndpointDocs", () => {
 
   it("generates GET endpoints for all provided resources", () => {
     for (const resource of mockResources) {
-      assert.match(docs, new RegExp(`GET http://localhost:9966${resource.restPath}`), `Missing endpoint for ${resource.uri}`);
+      assert.match(docs, new RegExp(`GET http://localhost:7256${resource.restPath}`), `Missing endpoint for ${resource.uri}`);
     }
   });
 
@@ -203,7 +203,7 @@ describe("generateEndpointDocs", () => {
   });
 
   it("generates no resource endpoints when resources array is empty", () => {
-    const docsNoResources = generateEndpointDocs(9966, "test-id", mockTools, []);
+    const docsNoResources = generateEndpointDocs(7256, "test-id", mockTools, []);
     assert.doesNotMatch(docsNoResources, /GET http/);
   });
 });