palmier 0.6.5 → 0.6.7

package/src/transports/http-transport.ts

@@ -5,8 +5,10 @@ import { StringCodec, type NatsConnection } from "nats";
 import { validateClient, addClient } from "../client-store.js";
 import { registerPending } from "../pending-requests.js";
 import * as fs from "node:fs";
-import { getTaskDir, parseTaskFile, spliceUserMessage } from "../task.js";
 import type { HostConfig, RpcMessage, RequiredPermission } from "../types.js";
+import { agentToolMap, ToolError, type ToolContext } from "../mcp-tools.js";
+import { handleMcpRequest, getAgentName } from "../mcp-handler.js";
+import { getTaskDir } from "../task.js";
 
 // ── Bundled PWA asset serving ───────────────────────────────────────────
 
@@ -87,18 +89,6 @@ export function detectLanIp(): string {
   return "127.0.0.1";
 }
 
-/** Find the latest (highest-numbered) run directory for a task. */
-function findLatestRunId(taskDir: string): string | null {
-  try {
-    const dirs = fs.readdirSync(taskDir)
-      .filter((f) => /^\d+$/.test(f) && fs.statSync(`${taskDir}/${f}`).isDirectory())
-      .sort();
-    return dirs.length > 0 ? dirs[dirs.length - 1] : null;
-  } catch {
-    return null;
-  }
-}
-
 /**
  * Start the HTTP transport: server with RPC, SSE, PWA proxy, pairing, and
  * localhost-only agent endpoints (notify, request-input, confirmation, permission).
@@ -172,10 +162,65 @@ export async function startHttpTransport(
     broadcastSseEvent({ task_id: taskId, ...payload });
   }
 
+  function makeToolContext(sessionId: string): ToolContext {
+    return { config, nc, publishEvent, sessionId, agentName: getAgentName(sessionId) };
+  }
+
   const server = http.createServer(async (req, res) => {
     const url = new URL(req.url ?? "/", `http://localhost:${port}`);
     const pathname = url.pathname;
 
+    // ── MCP streamable HTTP endpoint ──────────────────────────────────
+
+    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"] as string | undefined;
+        const ctx = makeToolContext(sessionId ?? "");
+        const result = await handleMcpRequest(body, sessionId, ctx);
+        if (result.sessionId) {
+          res.setHeader("Mcp-Session-Id", result.sessionId);
+        }
+        sendJson(res, 200, result.body);
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+      return;
+    }
+
+    // ── Auto-generated REST endpoints from MCP tool registry ──────────
+
+    if (req.method === "POST" && agentToolMap.has(pathname.slice(1))) {
+      if (!isLocalhost(req)) { sendJson(res, 403, { error: "localhost only" }); return; }
+      const tool = agentToolMap.get(pathname.slice(1))!;
+      try {
+        const body = await readBody(req);
+        const args = body.trim() ? JSON.parse(body) : {};
+        const { taskId } = args as { taskId?: string };
+        if (!taskId) {
+          sendJson(res, 400, { error: "taskId is required" });
+          return;
+        }
+        const taskDir = getTaskDir(config.projectRoot, taskId);
+        if (!fs.existsSync(taskDir)) {
+          sendJson(res, 404, { error: `Task not found: ${taskId}` });
+          return;
+        }
+        delete args.taskId;
+        const ctx = makeToolContext(taskId);
+        console.log(`[mcp] REST [${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));
+        sendJson(res, 200, result);
+      } catch (err: any) {
+        const status = err instanceof ToolError ? err.statusCode : 500;
+        console.error(`[mcp] REST ${tool.name} error:`, err.message ?? String(err));
+        sendJson(res, status, { error: err.message ?? String(err) });
+      }
+      return;
+    }
+
     // ── Localhost-only endpoints (no auth) ─────────────────────────────
 
     if (req.method === "POST" && pathname === "/event") {
@@ -217,121 +262,6 @@ export async function startHttpTransport(
       return;
     }
 
-    // ── POST /notify — send push notification via NATS ─────────────────
-
-    if (req.method === "POST" && pathname === "/notify") {
-      if (!isLocalhost(req)) { sendJson(res, 403, { error: "localhost only" }); return; }
-      if (!nc) { sendJson(res, 503, { error: "NATS not connected — push notifications require server mode" }); return; }
-
-      try {
-        const body = await readBody(req);
-        const { taskId: notifTaskId, title, body: notifBody } = JSON.parse(body) as { taskId?: string; title: string; body: string };
-        if (!title || !notifBody) { sendJson(res, 400, { error: "title and body are required" }); return; }
-
-        const sc = StringCodec();
-        const payload: Record<string, string> = { hostId: config.hostId, title, body: notifBody };
-        if (notifTaskId) payload.task_id = notifTaskId;
-        const subject = `host.${config.hostId}.push.send`;
-        const reply = await 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) {
-          sendJson(res, 200, { ok: true });
-        } else {
-          sendJson(res, 502, { error: result.error ?? "Push notification failed" });
-        }
-      } catch (err) {
-        sendJson(res, 500, { error: `Failed to send notification: ${err}` });
-      }
-      return;
-    }
-
-    // ── POST /request-input — held connection until user responds ────────
-
-    if (req.method === "POST" && pathname === "/request-input") {
-      if (!isLocalhost(req)) { sendJson(res, 403, { error: "localhost only" }); return; }
-      try {
-        const body = await readBody(req);
-        const { taskId, runId, descriptions } = JSON.parse(body) as {
-          taskId: string; runId?: string; descriptions: string[];
-        };
-        if (!taskId || !descriptions?.length) {
-          sendJson(res, 400, { error: "taskId and descriptions are required" });
-          return;
-        }
-
-        const taskDir = getTaskDir(config.projectRoot, taskId);
-        const task = parseTaskFile(taskDir);
-
-        // Resolve runId: use provided value, otherwise find the latest run directory
-        const effectiveRunId = runId ?? findLatestRunId(taskDir);
-
-        const pendingPromise = registerPending(taskId, "input", descriptions);
-
-        await publishEvent(taskId, {
-          event_type: "input-request",
-          host_id: config.hostId,
-          input_descriptions: descriptions,
-          name: task.frontmatter.name,
-        });
-
-        const response = await pendingPromise;
-
-        const questionsBlock = "\n\n" + descriptions.map((d) => `**${d}**`).join("\n");
-
-        if (response.length === 1 && response[0] === "aborted") {
-          await publishEvent(taskId, { event_type: "input-resolved", host_id: config.hostId, status: "aborted" });
-          if (effectiveRunId) {
-            spliceUserMessage(taskDir, effectiveRunId, { role: "user", time: Date.now(), content: "Aborted", type: "input" }, questionsBlock);
-            await publishEvent(taskId, { event_type: "result-updated", run_id: effectiveRunId });
-          }
-          sendJson(res, 200, { aborted: true });
-        } else {
-          await publishEvent(taskId, { event_type: "input-resolved", host_id: config.hostId, status: "provided" });
-          if (effectiveRunId) {
-            spliceUserMessage(taskDir, effectiveRunId, { role: "user", time: Date.now(), content: response.join("\n"), type: "input" }, questionsBlock);
-            await publishEvent(taskId, { event_type: "result-updated", run_id: effectiveRunId });
-          }
-          sendJson(res, 200, { values: response });
-        }
-      } catch (err) {
-        sendJson(res, 500, { error: String(err) });
-      }
-      return;
-    }
-
-    // ── POST /request-confirmation — held connection ────────────────────
-
-    if (req.method === "POST" && pathname === "/request-confirmation") {
-      if (!isLocalhost(req)) { sendJson(res, 403, { error: "localhost only" }); return; }
-      try {
-        const body = await readBody(req);
-        const { taskId } = JSON.parse(body) as { taskId: string };
-        if (!taskId) { sendJson(res, 400, { error: "taskId is required" }); return; }
-
-        const pendingPromise = registerPending(taskId, "confirmation");
-
-        await publishEvent(taskId, {
-          event_type: "confirm-request",
-          host_id: config.hostId,
-        });
-
-        const response = await pendingPromise;
-        const confirmed = response[0] === "confirmed";
-
-        await publishEvent(taskId, {
-          event_type: "confirm-resolved",
-          host_id: config.hostId,
-          status: confirmed ? "confirmed" : "aborted",
-        });
-
-        sendJson(res, 200, { confirmed });
-      } catch (err) {
-        sendJson(res, 500, { error: String(err) });
-      }
-      return;
-    }
-
     // ── POST /request-permission — held connection ──────────────────────
 
     if (req.method === "POST" && pathname === "/request-permission") {