@murphai/hosted-execution 0.1.15 → 0.1.17

package/node_modules/@murphai/device-syncd/dist/http.d.ts

@@ -0,0 +1,34 @@
+import type { IncomingHttpHeaders } from "node:http";
+import type { DeviceSyncError } from "./errors.ts";
+import type { DeviceSyncHttpConfig, NodeServerHandle } from "./types.ts";
+import type { DeviceSyncService } from "./service.ts";
+export interface CreateDeviceSyncHttpServerInput {
+    service: DeviceSyncService;
+    config?: DeviceSyncHttpConfig;
+    bodyLimitBytes?: number;
+}
+export declare function isLoopbackRemoteAddress(value: string | null | undefined): boolean;
+export declare function assertDeviceSyncControlRequest(input: {
+    headers: IncomingHttpHeaders;
+    remoteAddress: string | null | undefined;
+    controlToken: string;
+}): void;
+export declare function startDeviceSyncHttpServer(input: CreateDeviceSyncHttpServerInput): Promise<NodeServerHandle>;
+export declare function buildCallbackErrorRedirectLocation(input: {
+    returnTo: string | null;
+    provider: string;
+    errorCode: string;
+}): string | null;
+export declare function buildPublicDeviceSyncErrorPayload(error: DeviceSyncError): {
+    error: {
+        code: string;
+        message: string;
+        retryable: boolean;
+        details?: Record<string, unknown>;
+    };
+};
+export declare function renderCallbackHtml(input: {
+    title: string;
+    body: string;
+}): string;
+//# sourceMappingURL=http.d.ts.map

package/node_modules/@murphai/device-syncd/dist/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../src/http.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,mBAAmB,EAA2C,MAAM,WAAW,CAAC;AAC9F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAsCtD,MAAM,WAAW,+BAA+B;IAC9C,OAAO,EAAE,iBAAiB,CAAC;IAC3B,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAC9B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAOjF;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE;IACpD,OAAO,EAAE,mBAAmB,CAAC;IAC7B,aAAa,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACzC,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,IAAI,CAkBP;AAED,wBAAsB,yBAAyB,CAAC,KAAK,EAAE,+BAA+B,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA0CjH;AAshBD,wBAAgB,kCAAkC,CAAC,KAAK,EAAE;IACxD,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,MAAM,GAAG,IAAI,CAWhB;AAiED,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,eAAe,GAAG;IACzE,KAAK,EAAE;QACL,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,OAAO,CAAC;QACnB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACnC,CAAC;CACH,CASA;AA0ED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAkBjF"}

package/node_modules/@murphai/device-syncd/dist/http.js

@@ -0,0 +1,644 @@
+import { Buffer } from "node:buffer";
+import { timingSafeEqual } from "node:crypto";
+import { createServer } from "node:http";
+import { isLoopbackHostname } from "@murphai/runtime-state";
+import { deviceSyncError, isDeviceSyncError } from "./errors.js";
+import { DEFAULT_DEVICE_SYNC_HOST } from "./shared.js";
+import { resolveDeviceSyncWebhookVerificationResponse } from "./webhook-verification.js";
+const DEFAULT_BODY_LIMIT_BYTES = 1_048_576;
+const CONTROL_PLANE_WWW_AUTHENTICATE = 'Bearer realm="device-syncd-control-plane"';
+export function isLoopbackRemoteAddress(value) {
+    if (typeof value !== "string") {
+        return false;
+    }
+    const normalized = value.trim().toLowerCase();
+    return normalized === "::1" || normalized.startsWith("127.") || normalized.startsWith("::ffff:127.");
+}
+export function assertDeviceSyncControlRequest(input) {
+    if (!isLoopbackRemoteAddress(input.remoteAddress)) {
+        throw deviceSyncError({
+            code: "CONTROL_PLANE_LOOPBACK_REQUIRED",
+            message: "Device sync control routes only accept loopback requests.",
+            retryable: false,
+            httpStatus: 403,
+        });
+    }
+    if (!hasMatchingControlToken(input.headers, input.controlToken)) {
+        throw deviceSyncError({
+            code: "CONTROL_PLANE_AUTH_REQUIRED",
+            message: "Device sync control routes require a valid bearer token.",
+            retryable: false,
+            httpStatus: 401,
+        });
+    }
+}
+export async function startDeviceSyncHttpServer(input) {
+    const service = input.service;
+    const bodyLimitBytes = Math.max(1024, input.bodyLimitBytes ?? DEFAULT_BODY_LIMIT_BYTES);
+    const configuredHost = input.config?.host?.trim();
+    const host = configuredHost && configuredHost.length > 0 ? configuredHost : DEFAULT_DEVICE_SYNC_HOST;
+    assertLoopbackControlListenerHost(host);
+    const port = input.config?.port ?? 8788;
+    const controlToken = requireControlToken(input.config?.controlToken);
+    const publicListener = resolvePublicListener(input.config);
+    const controlServer = await startListener({
+        host,
+        port,
+        service,
+        bodyLimitBytes,
+        controlToken,
+        surface: publicListener ? "control" : "combined",
+        config: input.config,
+    });
+    const publicServer = publicListener
+        ? await startListener({
+            host: publicListener.host,
+            port: publicListener.port,
+            service,
+            bodyLimitBytes,
+            controlToken,
+            surface: "public",
+            config: input.config,
+        })
+        : null;
+    return {
+        control: controlServer.address,
+        public: publicServer?.address ?? null,
+        async close() {
+            if (publicServer) {
+                await closeServer(publicServer.server);
+            }
+            await closeServer(controlServer.server);
+        },
+    };
+}
+const DEVICE_SYNC_HTTP_ROUTES = [
+    createStaticRoute({
+        method: "GET",
+        pattern: "/",
+        surface: "control",
+        handle({ response, service }) {
+            sendJson(response, 200, {
+                ok: true,
+                providers: service.describeProviders(),
+                summary: service.summarize(),
+            });
+        },
+    }),
+    createStaticRoute({
+        method: "GET",
+        pattern: "/healthz",
+        surface: "control",
+        handle({ response, service }) {
+            sendJson(response, 200, {
+                ok: true,
+                summary: service.summarize(),
+            });
+        },
+    }),
+    createStaticRoute({
+        method: "GET",
+        pattern: "/providers",
+        surface: "control",
+        handle({ response, service }) {
+            sendJson(response, 200, {
+                providers: service.describeProviders(),
+            });
+        },
+    }),
+    createParameterizedRoute({
+        method: "GET",
+        pattern: /^\/connect\/([^/]+)$/u,
+        paramNames: ["provider"],
+        surface: "control",
+        async handle({ response, service, url, params }) {
+            const result = await service.startConnection({
+                provider: params.provider ?? "",
+                returnTo: url.searchParams.get("returnTo"),
+            });
+            redirect(response, result.authorizationUrl);
+        },
+    }),
+    createParameterizedRoute({
+        method: "POST",
+        pattern: /^\/providers\/([^/]+)\/connect$/u,
+        paramNames: ["provider"],
+        surface: "control",
+        async handle({ request, response, service, bodyLimitBytes, params }) {
+            const body = await maybeReadJsonBody(request, bodyLimitBytes);
+            const result = await service.startConnection({
+                provider: params.provider ?? "",
+                returnTo: readStringField(body, "returnTo"),
+            });
+            sendJson(response, 200, result);
+        },
+    }),
+    createParameterizedRoute({
+        method: "GET",
+        pattern: /^\/oauth\/([^/]+)\/callback$/u,
+        paramNames: ["provider"],
+        surface: "public",
+        async handle({ response, service, url, params }) {
+            const provider = params.provider ?? "";
+            try {
+                const result = await service.handleOAuthCallback({
+                    provider,
+                    code: url.searchParams.get("code"),
+                    state: url.searchParams.get("state"),
+                    scope: url.searchParams.get("scope"),
+                    error: url.searchParams.get("error"),
+                    errorDescription: url.searchParams.get("error_description"),
+                });
+                if (result.returnTo) {
+                    const destination = new URL(result.returnTo);
+                    destination.searchParams.set("deviceSyncStatus", "connected");
+                    destination.searchParams.set("deviceSyncProvider", result.account.provider);
+                    destination.searchParams.set("deviceSyncAccountId", result.account.id);
+                    redirect(response, destination.toString());
+                    return;
+                }
+                sendHtml(response, 200, renderCallbackHtml({
+                    title: `${formatProviderLabel(result.account.provider)} connected`,
+                    body: `Connected ${formatProviderLabel(result.account.provider)} account ${result.account.id} successfully.`,
+                }));
+            }
+            catch (error) {
+                if (isDeviceSyncError(error)) {
+                    sendCallbackErrorResponse(response, provider, error);
+                    return;
+                }
+                throw error;
+            }
+        },
+    }),
+    createParameterizedRoute({
+        method: "GET",
+        pattern: /^\/webhooks\/([^/]+)$/u,
+        paramNames: ["provider"],
+        surface: "public",
+        handle({ response, service, url, config, params }) {
+            const provider = params.provider ?? "";
+            sendJson(response, 200, resolveDeviceSyncWebhookVerificationResponse({
+                provider,
+                registry: service.registry,
+                url,
+                verificationToken: config?.ouraWebhookVerificationToken ?? null,
+            }));
+        },
+    }),
+    createParameterizedRoute({
+        method: "POST",
+        pattern: /^\/webhooks\/([^/]+)$/u,
+        paramNames: ["provider"],
+        surface: "public",
+        async handle({ request, response, service, bodyLimitBytes, params }) {
+            const rawBody = await readRequestBody(request, bodyLimitBytes);
+            const result = await service.handleWebhook(params.provider ?? "", toFetchHeaders(request), rawBody);
+            sendJson(response, 202, result);
+        },
+    }),
+    createStaticRoute({
+        method: "GET",
+        pattern: "/accounts",
+        surface: "control",
+        handle({ response, service, url }) {
+            sendJson(response, 200, {
+                accounts: service.listAccounts(url.searchParams.get("provider") ?? undefined),
+            });
+        },
+    }),
+    createParameterizedRoute({
+        method: "GET",
+        pattern: /^\/accounts\/([^/]+)$/u,
+        paramNames: ["accountId"],
+        surface: "control",
+        handle({ response, service, params }) {
+            const account = service.getAccount(params.accountId ?? "");
+            if (!account) {
+                sendJson(response, 404, {
+                    error: {
+                        code: "ACCOUNT_NOT_FOUND",
+                        message: "Device sync account was not found.",
+                    },
+                });
+                return;
+            }
+            sendJson(response, 200, { account });
+        },
+    }),
+    createParameterizedRoute({
+        method: "POST",
+        pattern: /^\/accounts\/([^/]+)\/reconcile$/u,
+        paramNames: ["accountId"],
+        surface: "control",
+        handle({ response, service, params }) {
+            const result = service.queueManualReconcile(params.accountId ?? "");
+            sendJson(response, 202, result);
+        },
+    }),
+    createParameterizedRoute({
+        method: "POST",
+        pattern: /^\/accounts\/([^/]+)\/disconnect$/u,
+        paramNames: ["accountId"],
+        surface: "control",
+        async handle({ response, service, params }) {
+            const result = await service.disconnectAccount(params.accountId ?? "");
+            sendJson(response, 200, result);
+        },
+    }),
+];
+async function routeRequest(input) {
+    const method = input.request.method ?? "GET";
+    const url = new URL(input.request.url ?? "/", `${input.service.publicBaseUrl}/`);
+    const basePath = new URL(`${input.service.publicBaseUrl}/`).pathname.replace(/\/+$/u, "");
+    const pathname = stripBasePath(url.pathname, basePath);
+    const routeMatch = matchDeviceSyncHttpRoute(method, pathname);
+    if (!routeMatch || !surfaceAllowsRoute(input.surface, routeMatch.route)) {
+        sendJson(input.response, 404, {
+            error: {
+                code: "NOT_FOUND",
+                message: `No route for ${method} ${pathname}`,
+            },
+        });
+        return;
+    }
+    if (routeMatch.route.surface === "control") {
+        assertDeviceSyncControlRequest({
+            headers: input.request.headers,
+            remoteAddress: input.request.socket.remoteAddress,
+            controlToken: input.controlToken,
+        });
+    }
+    await routeMatch.route.handle({
+        request: input.request,
+        response: input.response,
+        service: input.service,
+        bodyLimitBytes: input.bodyLimitBytes,
+        config: input.config,
+        url,
+        pathname,
+        params: routeMatch.params,
+    });
+}
+async function startListener(input) {
+    const server = createServer(async (request, response) => {
+        try {
+            await routeRequest({
+                request,
+                response,
+                service: input.service,
+                bodyLimitBytes: input.bodyLimitBytes,
+                controlToken: input.controlToken,
+                surface: input.surface,
+                config: input.config,
+            });
+        }
+        catch (error) {
+            sendError(response, error);
+        }
+    });
+    const address = await listenServer(server, input.host, input.port);
+    return {
+        server,
+        address,
+    };
+}
+async function listenServer(server, host, port) {
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, host, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        throw new TypeError("Device sync HTTP server did not expose a TCP listener address.");
+    }
+    return {
+        host,
+        port: address.port,
+    };
+}
+async function closeServer(server) {
+    await new Promise((resolve, reject) => {
+        server.close((error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+function assertLoopbackControlListenerHost(host) {
+    if (isLoopbackHostname(host)) {
+        return;
+    }
+    throw new TypeError("Device sync control listener host must be a loopback hostname or address. Use publicHost/publicPort for externally reachable callback and webhook routes.");
+}
+function requireControlToken(controlToken) {
+    if (typeof controlToken === "string" && controlToken.trim()) {
+        return controlToken.trim();
+    }
+    throw new TypeError("Device sync control routes require DEVICE_SYNC_CONTROL_TOKEN.");
+}
+function resolvePublicListener(config) {
+    const publicHost = typeof config?.publicHost === "string" ? config.publicHost.trim() : "";
+    const publicPort = config?.publicPort;
+    if (!publicHost && publicPort === undefined) {
+        return null;
+    }
+    if (!publicHost || publicPort === undefined) {
+        throw new TypeError("Set both publicHost and publicPort to expose a separate public callback/webhook listener.");
+    }
+    return {
+        host: publicHost,
+        port: publicPort,
+    };
+}
+function createStaticRoute(input) {
+    return {
+        method: input.method,
+        pattern: input.pattern,
+        surface: input.surface,
+        parseParams(pathname) {
+            return pathname === input.pattern ? {} : null;
+        },
+        async handle(routeInput) {
+            await input.handle(routeInput);
+        },
+    };
+}
+function surfaceAllowsRoute(surface, route) {
+    return surface === "combined" || surface === route.surface;
+}
+function createParameterizedRoute(input) {
+    return {
+        method: input.method,
+        pattern: input.pattern,
+        surface: input.surface,
+        parseParams(pathname) {
+            return parseRouteParams(pathname, input.pattern, input.paramNames);
+        },
+        async handle(routeInput) {
+            await input.handle(routeInput);
+        },
+    };
+}
+function matchDeviceSyncHttpRoute(method, pathname) {
+    for (const route of DEVICE_SYNC_HTTP_ROUTES) {
+        if (route.method !== method) {
+            continue;
+        }
+        const params = route.parseParams(pathname);
+        if (params) {
+            return {
+                route,
+                params,
+            };
+        }
+    }
+    return null;
+}
+function parseRouteParams(pathname, pattern, paramNames) {
+    const match = pathname.match(pattern);
+    if (!match) {
+        return null;
+    }
+    const params = {};
+    for (const [index, paramName] of paramNames.entries()) {
+        params[paramName] = decodeURIComponent(match[index + 1] ?? "");
+    }
+    return params;
+}
+async function maybeReadJsonBody(request, limitBytes) {
+    const rawBody = await readRequestBody(request, limitBytes);
+    if (rawBody.length === 0) {
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(rawBody.toString("utf8"));
+    }
+    catch (error) {
+        throw new TypeError("Request body must be valid JSON.", { cause: error });
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new TypeError("Request body must be a JSON object.");
+    }
+    return parsed;
+}
+async function readRequestBody(request, limitBytes) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.length;
+        if (size > limitBytes) {
+            throw new RangeError(`Request body exceeded ${limitBytes} bytes.`);
+        }
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks);
+}
+function toFetchHeaders(request) {
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(request.headers)) {
+        if (Array.isArray(value)) {
+            for (const entry of value) {
+                headers.append(key, entry);
+            }
+            continue;
+        }
+        if (typeof value === "string") {
+            headers.set(key, value);
+        }
+    }
+    return headers;
+}
+function stripBasePath(pathname, basePath) {
+    if (!basePath || basePath === "/") {
+        return pathname || "/";
+    }
+    if (pathname === basePath) {
+        return "/";
+    }
+    if (pathname.startsWith(`${basePath}/`)) {
+        return pathname.slice(basePath.length) || "/";
+    }
+    return pathname || "/";
+}
+function sendJson(response, statusCode, payload) {
+    const body = JSON.stringify(payload, null, 2);
+    response.statusCode = statusCode;
+    response.setHeader("Content-Type", "application/json; charset=utf-8");
+    response.setHeader("Content-Length", Buffer.byteLength(body));
+    response.end(body);
+}
+function sendHtml(response, statusCode, body) {
+    response.statusCode = statusCode;
+    response.setHeader("Content-Type", "text/html; charset=utf-8");
+    response.setHeader("Content-Length", Buffer.byteLength(body));
+    response.end(body);
+}
+function sendText(response, statusCode, body) {
+    response.statusCode = statusCode;
+    response.setHeader("Content-Type", "text/plain; charset=utf-8");
+    response.setHeader("Content-Length", Buffer.byteLength(body));
+    response.end(body);
+}
+function redirect(response, location) {
+    response.statusCode = 302;
+    response.setHeader("Location", location);
+    response.end();
+}
+export function buildCallbackErrorRedirectLocation(input) {
+    if (!input.returnTo) {
+        return null;
+    }
+    const destination = new URL(input.returnTo);
+    destination.searchParams.delete("deviceSyncErrorMessage");
+    destination.searchParams.set("deviceSyncStatus", "error");
+    destination.searchParams.set("deviceSyncProvider", input.provider);
+    destination.searchParams.set("deviceSyncError", input.errorCode);
+    return destination.toString();
+}
+function sendCallbackErrorResponse(response, fallbackProvider, error) {
+    const provider = error.details ? readStringField(error.details, "provider") ?? fallbackProvider : fallbackProvider;
+    const returnTo = error.details ? readStringField(error.details, "returnTo") : null;
+    const redirectLocation = buildCallbackErrorRedirectLocation({
+        returnTo,
+        provider,
+        errorCode: error.code,
+    });
+    if (redirectLocation) {
+        redirect(response, redirectLocation);
+        return;
+    }
+    sendHtml(response, error.httpStatus, renderCallbackHtml({
+        title: `${formatProviderLabel(provider)} connection failed`,
+        body: error.message,
+    }));
+}
+function sendError(response, error) {
+    if (isDeviceSyncError(error)) {
+        if (error.code === "CONTROL_PLANE_AUTH_REQUIRED") {
+            response.setHeader("WWW-Authenticate", CONTROL_PLANE_WWW_AUTHENTICATE);
+        }
+        sendJson(response, error.httpStatus, buildPublicDeviceSyncErrorPayload(error));
+        return;
+    }
+    if (error instanceof RangeError) {
+        sendJson(response, 413, {
+            error: {
+                code: "PAYLOAD_TOO_LARGE",
+                message: error.message,
+            },
+        });
+        return;
+    }
+    if (error instanceof TypeError) {
+        sendJson(response, 400, {
+            error: {
+                code: "BAD_REQUEST",
+                message: error.message,
+            },
+        });
+        return;
+    }
+    sendJson(response, 500, {
+        error: {
+            code: "INTERNAL_ERROR",
+            message: "Internal server error.",
+        },
+    });
+}
+export function buildPublicDeviceSyncErrorPayload(error) {
+    return {
+        error: {
+            code: error.code,
+            message: error.message,
+            retryable: error.retryable,
+            details: buildPublicDeviceSyncErrorDetails(error.details),
+        },
+    };
+}
+function buildPublicDeviceSyncErrorDetails(details) {
+    const status = readDeviceSyncErrorStatusDetail(details);
+    return status === null ? undefined : { status };
+}
+function readDeviceSyncErrorStatusDetail(details) {
+    if (!details) {
+        return null;
+    }
+    const statusValue = details.status;
+    const status = typeof statusValue === "number"
+        ? statusValue
+        : typeof statusValue === "string" && statusValue.trim()
+            ? Number(statusValue)
+            : Number.NaN;
+    return Number.isInteger(status) && status >= 100 && status <= 599 ? status : null;
+}
+function readStringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function hasMatchingControlToken(headers, expectedToken) {
+    const providedToken = readBearerToken(headers.authorization);
+    if (!providedToken) {
+        return false;
+    }
+    const expected = Buffer.from(expectedToken, "utf8");
+    const provided = Buffer.from(providedToken, "utf8");
+    return expected.length === provided.length && timingSafeEqual(expected, provided);
+}
+function readBearerToken(value) {
+    const header = readHeaderValue(value);
+    if (!header) {
+        return null;
+    }
+    const match = header.match(/^bearer\s+(.+)$/iu);
+    return match?.[1]?.trim() || null;
+}
+function readHeaderValue(value) {
+    if (Array.isArray(value)) {
+        return value.length === 1 ? readHeaderValue(value[0]) : null;
+    }
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function formatProviderLabel(provider) {
+    return (provider
+        .split(/[-_\s]+/u)
+        .filter(Boolean)
+        .map((token) => token[0]?.toUpperCase() + token.slice(1))
+        .join(" ") || provider);
+}
+export function renderCallbackHtml(input) {
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>${escapeHtml(input.title)}</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <style>
+      body { font-family: system-ui, sans-serif; max-width: 640px; margin: 48px auto; padding: 0 16px; }
+      h1 { font-size: 24px; }
+      p { line-height: 1.5; }
+    </style>
+  </head>
+  <body>
+    <h1>${escapeHtml(input.title)}</h1>
+    <p>${escapeHtml(input.body)}</p>
+  </body>
+</html>`;
+}
+function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+//# sourceMappingURL=http.js.map