palmier 0.6.6 → 0.6.8

package/src/commands/run.ts

@@ -65,12 +65,9 @@ async function invokeAgentWithRetries(
     const { command, args, stdin, env: agentEnv } = ctx.agent.getTaskRunCommandLine(
       invokeTask, undefined, ctx.task.frontmatter.yolo_mode ? "yolo" : ctx.transientPermissions,
     );
-    const truncate = (s: string, max = 100) => s.length > max ? s.slice(0, max) + "…" : s;
-    const displayArgs = args.map((a) => truncate(a));
-    console.log(`[invoke] ${command} ${displayArgs.join(" ")}${stdin ? ` (stdin: ${truncate(stdin, 100)})` : ""}`);
     const result = await spawnCommand(command, args, {
       cwd: getRunDir(ctx.taskDir, ctx.runId),
-      env: { ...ctx.guiEnv, ...agentEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, 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 ?? 9966) },
       echoStdout: true,
       resolveOnFailure: true,
       stdin,
@@ -324,7 +321,7 @@ async function runCommandTriggeredMode(
 
   const child = spawnStreamingCommand(commandStr, {
     cwd: getRunDir(ctx.taskDir, ctx.runId),
-    env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, 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 ?? 9966) },
   });
 
   let linesProcessed = 0;
@@ -516,10 +513,10 @@ async function requestConfirmation(
   taskDir: string,
 ): Promise<boolean> {
   const port = config.httpPort ?? 9966;
-  const res = await fetch(`http://localhost:${port}/request-confirmation`, {
+  const res = await fetch(`http://localhost:${port}/request-confirmation?taskId=${encodeURIComponent(task.frontmatter.id)}`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ taskId: task.frontmatter.id, taskName: task.frontmatter.name }),
+    body: JSON.stringify({ description: `Run task "${task.frontmatter.name || task.frontmatter.id}"?` }),
   });
   const body = await res.json() as { confirmed?: boolean; error?: string };
   if (typeof body.confirmed !== "boolean") {

package/src/location-device.ts

@@ -0,0 +1,35 @@
+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 interface LocationDevice {
+  clientToken: string;
+  fcmToken: string;
+}
+
+export function getLocationDevice(): LocationDevice | null {
+  try {
+    if (!fs.existsSync(LOCATION_FILE)) return null;
+    const raw = fs.readFileSync(LOCATION_FILE, "utf-8");
+    const data = JSON.parse(raw) as LocationDevice;
+    if (!data.clientToken || !data.fcmToken) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+export function setLocationDevice(clientToken: string, fcmToken: string): void {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(LOCATION_FILE, JSON.stringify({ clientToken, fcmToken }, null, 2), "utf-8");
+}
+
+export function clearLocationDevice(): void {
+  try {
+    if (fs.existsSync(LOCATION_FILE)) fs.unlinkSync(LOCATION_FILE);
+  } catch {
+    // ignore
+  }
+}

package/src/mcp-handler.ts

@@ -0,0 +1,133 @@
+import { randomUUID } from "crypto";
+import { agentTools, agentToolMap, ToolError, type ToolContext } from "./mcp-tools.js";
+
+interface JsonRpcRequest {
+  jsonrpc: string;
+  id?: string | number | null;
+  method: string;
+  params?: Record<string, unknown>;
+}
+
+export interface McpResponse {
+  body: object;
+  sessionId?: string;
+}
+
+// Session-to-agent name map with 24h TTL
+const SESSION_TTL_MS = 24 * 60 * 60 * 1000;
+const sessionAgents = new Map<string, { agentName: string; expiresAt: number }>();
+
+export function getAgentName(sessionId: string): string | undefined {
+  const entry = sessionAgents.get(sessionId);
+  if (!entry) return undefined;
+  if (Date.now() > entry.expiresAt) {
+    sessionAgents.delete(sessionId);
+    return undefined;
+  }
+  return entry.agentName;
+}
+
+function pruneExpiredSessions(): void {
+  const now = Date.now();
+  for (const [id, entry] of sessionAgents) {
+    if (now > entry.expiresAt) sessionAgents.delete(id);
+  }
+}
+
+function rpcError(id: string | number | null, code: number, message: string): object {
+  return { jsonrpc: "2.0", id, error: { code, message } };
+}
+
+function rpcResult(id: string | number | null, result: unknown): object {
+  return { jsonrpc: "2.0", id, result };
+}
+
+export async function handleMcpRequest(body: string, sessionId: string | undefined, ctx: ToolContext): Promise<McpResponse> {
+  let req: JsonRpcRequest;
+  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 as { name?: string; version?: string } | undefined;
+      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: {} },
+          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 as string | undefined;
+      const args = (req.params?.arguments ?? {}) as Record<string, unknown>;
+
+      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: any) {
+        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,
+          }),
+        };
+      }
+    }
+
+    default:
+      console.warn(`${logPrefix} Unknown method: ${req.method}`);
+      return { body: rpcError(id, -32601, `Method not found: ${req.method}`) };
+  }
+}

package/src/mcp-tools.ts

@@ -0,0 +1,253 @@
+import { StringCodec, type NatsConnection } from "nats";
+import { registerPending } from "./pending-requests.js";
+import { getLocationDevice } from "./location-device.js";
+import type { HostConfig } from "./types.js";
+
+export class ToolError extends Error {
+  constructor(message: string, public statusCode: number = 500) {
+    super(message);
+  }
+}
+
+export interface ToolContext {
+  config: HostConfig;
+  nc: NatsConnection | undefined;
+  publishEvent: (id: string, payload: Record<string, unknown>) => Promise<void>;
+  sessionId: string;
+  agentName?: string;
+}
+
+export interface ToolDefinition {
+  name: string;
+  /** First line is the summary (used as endpoint header). Remaining lines become bullet points in docs. */
+  description: string[];
+  inputSchema: object;
+  handler: (args: Record<string, unknown>, ctx: ToolContext) => Promise<unknown>;
+}
+
+const notifyTool: ToolDefinition = {
+  name: "notify",
+  description: [
+    "Send a push notification to the user's device.",
+    'Response: `{"ok": true}` on success.',
+  ],
+  inputSchema: {
+    type: "object",
+    properties: {
+      title: { type: "string", description: "Notification title" },
+      body: { type: "string", description: "Notification body" },
+    },
+    required: ["title", "body"],
+  },
+  async handler(args, ctx) {
+    const { title, body } = args as { title: string; body: string };
+    if (!title || !body) throw new ToolError("title and body are required", 400);
+    if (!ctx.nc) throw new ToolError("NATS not connected — push notifications require server mode", 503);
+
+    const sc = StringCodec();
+    const payload: Record<string, string> = { hostId: ctx.config.hostId, title, body };
+    if (ctx.sessionId) payload.session_id = ctx.sessionId;
+    if (ctx.agentName) payload.agent_name = ctx.agentName;
+    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)) as { ok?: boolean; error?: string };
+
+    if (result.ok) return { ok: true };
+    throw new ToolError(result.error ?? "Push notification failed", 502);
+  },
+};
+
+const requestInputTool: ToolDefinition = {
+  name: "request-input",
+  description: [
+    "Request input from the user.",
+    "The request blocks until the user responds.",
+    'Response: `{"values": ["answer1", "answer2"]}` on success, or `{"aborted": true}` if the user declines.',
+    "When you need information from the user (credentials, answers to questions, preferences, clarifications, etc.), do not guess, fail, or prompt via stdout, even in a non-interactive environment — use this endpoint instead.",
+  ],
+  inputSchema: {
+    type: "object",
+    properties: {
+      description: { type: "string", description: "Context or heading for the input request" },
+      questions: {
+        type: "array",
+        items: { type: "string" },
+        description: "Questions to present to the user",
+        minItems: 1,
+      },
+    },
+    required: ["questions"],
+  },
+  async handler(args, ctx) {
+    const { description, questions } = args as { description?: string; questions: string[] };
+    if (!questions?.length) throw new ToolError("questions is required", 400);
+
+    const pendingPromise = registerPending(ctx.sessionId, "input", questions);
+
+    await ctx.publishEvent("_input", {
+      event_type: "input-request",
+      host_id: ctx.config.hostId,
+      session_id: ctx.sessionId,
+      agent_name: ctx.agentName,
+      description,
+      input_questions: questions,
+    });
+
+    const response = await pendingPromise;
+
+    if (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",
+      });
+      return { aborted: true };
+    }
+
+    await ctx.publishEvent("_input", {
+      event_type: "input-resolved", host_id: ctx.config.hostId,
+      session_id: ctx.sessionId, status: "provided",
+    });
+    return { values: response };
+  },
+};
+
+const requestConfirmationTool: ToolDefinition = {
+  name: "request-confirmation",
+  description: [
+    "Request confirmation from the user.",
+    "The request blocks until the user confirms or aborts.",
+    'Response: `{"confirmed": true}` or `{"confirmed": false}`.',
+  ],
+  inputSchema: {
+    type: "object",
+    properties: {
+      description: { type: "string", description: "What the user is confirming" },
+    },
+    required: ["description"],
+  },
+  async handler(args, ctx) {
+    const { description } = args as { description: string };
+    if (!description) throw new ToolError("description is required", 400);
+
+    const pendingPromise = registerPending(ctx.sessionId, "confirmation");
+
+    await ctx.publishEvent("_confirm", {
+      event_type: "confirm-request",
+      host_id: ctx.config.hostId,
+      session_id: ctx.sessionId,
+      agent_name: ctx.agentName,
+      description,
+    });
+
+    const response = await pendingPromise;
+    const confirmed = response[0] === "confirmed";
+
+    await ctx.publishEvent("_confirm", {
+      event_type: "confirm-resolved",
+      host_id: ctx.config.hostId,
+      session_id: ctx.sessionId,
+      status: confirmed ? "confirmed" : "aborted",
+    });
+
+    return { confirmed };
+  },
+};
+
+const deviceGeolocationTool: ToolDefinition = {
+  name: "device-geolocation",
+  description: [
+    "Get the GPS location of the user's mobile device.",
+    "When you need the user's real-time location, use this endpoint.",
+    "Blocks until the device responds (up to 30 seconds).",
+    'Response: `{"latitude": ..., "longitude": ..., "accuracy": ..., "timestamp": ...}` 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 locDevice = getLocationDevice();
+    if (!locDevice) 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 })),
+      { 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 locationPromise = new Promise<string>((resolve, reject) => {
+      const sub = ctx.nc!.subscribe(`host.${ctx.config.hostId}.geolocation.${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 locationData = JSON.parse(await locationPromise);
+    if (locationData.error) return { error: locationData.error };
+    return locationData;
+  },
+};
+
+export const agentTools: ToolDefinition[] = [notifyTool, requestInputTool, requestConfirmationTool, deviceGeolocationTool];
+export const agentToolMap = new Map<string, ToolDefinition>(agentTools.map((t) => [t.name, t]));
+
+/**
+ * Generate the HTTP Endpoints markdown section for agent-instructions.md from the tool registry.
+ */
+export function generateEndpointDocs(port: number, taskId: string): string {
+  const baseUrl = `http://localhost:${port}`;
+  const lines: string[] = [
+    `The following HTTP endpoints are available during task execution. Use curl to call them.`,
+    "",
+  ];
+
+  for (const tool of agentTools) {
+    const schema = tool.inputSchema as { properties?: Record<string, { type?: string; description?: string; items?: { type?: string } }>; required?: string[] };
+    const props = schema.properties ?? {};
+    const required = new Set(schema.required ?? []);
+
+    // Build example JSON (body only, no taskId)
+    const example: Record<string, unknown> = {};
+    for (const [key, prop] of Object.entries(props)) {
+      if (prop.type === "array") example[key] = ["..."];
+      else example[key] = "...";
+    }
+
+    const queryUrl = `${baseUrl}/${tool.name}?taskId=${taskId}`;
+    const [header, ...details] = tool.description;
+
+    lines.push(`**\`POST ${queryUrl}\`** — ${header}`);
+    if (Object.keys(example).length > 0) {
+      lines.push("```json");
+      lines.push(JSON.stringify(example));
+      lines.push("```");
+    }
+    for (const [key, prop] of Object.entries(props)) {
+      const req = required.has(key) ? "required" : "optional";
+      let typeStr = prop.type ?? "unknown";
+      if (prop.type === "array" && prop.items?.type) typeStr = `${prop.items.type} array`;
+      lines.push(`- \`${key}\` (${req}, ${typeStr}): ${prop.description ?? ""}`);
+    }
+    for (const detail of details) {
+      lines.push(`- ${detail}`);
+    }
+
+    lines.push("");
+  }
+
+  return lines.join("\n").trimEnd();
+}

package/src/rpc-handler.ts

@@ -13,6 +13,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 { currentVersion, performUpdate } from "./update-checker.js";
 import { parseReportFiles, parseTaskOutcome, stripPalmierMarkers } from "./commands/run.js";
 import type { HostConfig, ParsedTask, RpcMessage, ConversationMessage } from "./types.js";
@@ -125,7 +126,6 @@ async function generatePlan(
   const fullPrompt = PLAN_GENERATION_PROMPT + userPrompt;
   const planAgent = getAgent(agentName);
   const { command, args, stdin, env: agentEnv } = planAgent.getPlanGenerationCommandLine(fullPrompt);
-  console.log(`[generatePlan] Running: ${command} ${args.join(" ")}`);
 
   const { output } = await spawnCommand(command, args, {
     cwd: projectRoot,
@@ -166,27 +166,29 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
       body: task.body,
       status: status ? {
         ...status,
-        ...(pending?.type === "confirmation" ? { pending_confirmation: true } : {}),
         ...(pending?.type === "permission" ? { pending_permission: pending.params } : {}),
-        ...(pending?.type === "input" ? { pending_input: pending.params } : {}),
       } : undefined,
     };
   }
 
   async function handleRpc(request: RpcMessage): Promise<unknown> {
-    // Client token validation: skip for trusted localhost requests
-    if (!request.localhost && (!request.clientToken || !validateClient(request.clientToken))) {
+    // Client token validation: skip for trusted localhost requests and
+    // task.user_input (server-originated push responses; gated by getPending instead)
+    const skipAuth = request.method === "task.user_input";
+    if (!skipAuth && !request.localhost && (!request.clientToken || !validateClient(request.clientToken))) {
       return { error: "Unauthorized" };
     }
 
     switch (request.method) {
       case "task.list": {
         const tasks = listTasks(config.projectRoot);
+        const locDevice = getLocationDevice();
         return {
           tasks: tasks.map((task) => flattenTask(task)),
           agents: config.agents ?? [],
           version: currentVersion,
           host_platform: process.platform,
+          location_client_token: locDevice?.clientToken ?? null,
         };
       }
 
@@ -440,7 +442,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         const child = crossSpawn(cmd, cmdArgs, {
           cwd: followupRunDir,
           stdio: [stdin != null ? "pipe" : "ignore", "pipe", "pipe"],
-          env: { ...process.env, ...followupAgentEnv, PALMIER_TASK_ID: params.id },
+          env: { ...process.env, ...followupAgentEnv },
           windowsHide: true,
         });
         if (stdin != null) child.stdin!.end(stdin);
@@ -577,9 +579,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         return {
           task_id: params.id,
           ...status,
-          ...(pending?.type === "confirmation" ? { pending_confirmation: true } : {}),
           ...(pending?.type === "permission" ? { pending_permission: pending.params } : {}),
-          ...(pending?.type === "input" ? { pending_input: pending.params } : {}),
         };
       }
 
@@ -690,6 +690,19 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         return { ok: true };
       }
 
+      case "device.location.enable": {
+        const params = request.params as { fcmToken: string };
+        if (!params.fcmToken) return { error: "fcmToken is required" };
+        const clientToken = request.clientToken ?? "";
+        setLocationDevice(clientToken, params.fcmToken);
+        return { ok: true };
+      }
+
+      case "device.location.disable": {
+        clearLocationDevice();
+        return { ok: true };
+      }
+
       default:
         return { error: `Unknown method: ${request.method}` };
     }

package/src/spawn-command.ts

@@ -89,8 +89,10 @@ export function spawnCommand(
     const finalArgs = process.platform === "win32"
       ? args.map((a) => a.replace(/[\r\n]+/g, " "))
       : args;
+    const truncate = (s: string, max = 100) => s.length > max ? s.slice(0, max) + "..." : s;
+    const displayArgs = finalArgs.map((arg) => truncate(arg));
 
-    // console.log(`[spawn] ${command} ${finalArgs.join(" ")}`);
+    console.log(`[spawn] ${command} ${displayArgs.join(" ")}`);
 
     const child = crossSpawn(command, finalArgs, {
       cwd: opts.cwd,