hono-webhooks 0.1.0

package/dist/cli.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { parseArgs } from "node:util";
+var HELP = `Usage: hono-webhooks <module> <command> [options]
+
+<module> exports the result of createWebhooks(), as default or named export.
+
+Commands:
+  list                      List the webhooks
+  schema <path>             Print the JSON Schemas of the webhooks at <path>
+  test <method> <path>      Send a request through the webhooks app
+
+Options for test:
+  -b, --body <text>         Request body (JSON sets content-type: application/json)
+  -q, --query <params>      Query string, e.g. "a=1&b=2"
+  -H, --header <k: v>       Request header, repeatable
+
+Examples:
+  hono-webhooks ./src/webhooks.ts list
+  hono-webhooks ./src/webhooks.ts schema /orders/:id
+  hono-webhooks ./src/webhooks.ts test POST /orders/42 -b '{"total":10}'
+`;
+var { values, positionals } = parseArgs({
+  allowPositionals: true,
+  options: {
+    help: { type: "boolean", short: "h" },
+    body: { type: "string", short: "b" },
+    query: { type: "string", short: "q" },
+    header: { type: "string", short: "H", multiple: true }
+  }
+});
+var [modulePath, command, ...args] = positionals;
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+function isWebhooksApp(value) {
+  return typeof value === "object" && value !== null && Array.isArray(value.webhooks) && typeof value.request === "function";
+}
+async function loadApp(path) {
+  const mod = await import(pathToFileURL(resolve(path)).href);
+  const app = [mod.default, ...Object.values(mod)].find(isWebhooksApp);
+  return app ?? fail(`${path} does not export a createWebhooks() app`);
+}
+function jsonSchemaOf(schema) {
+  const props = schema["~standard"];
+  try {
+    return props?.jsonSchema?.input({ target: "draft-2020-12" });
+  } catch {
+    return;
+  }
+}
+async function main() {
+  if (values.help || !modulePath || !command) {
+    console.log(HELP);
+    return;
+  }
+  const app = await loadApp(modulePath);
+  if (command === "list") {
+    for (const { config } of app.webhooks) {
+      const validates = ["params", "query", "headers", "body"].filter((key) => config[key]).join(", ");
+      console.log(`${config.method.padEnd(7)} ${config.path}${config.description ? `  ${config.description}` : ""}`);
+      if (validates)
+        console.log(`        validates ${validates}`);
+    }
+    return;
+  }
+  if (command === "schema") {
+    const [path] = args;
+    const matches = app.webhooks.filter((w) => w.config.path === path);
+    if (!matches.length)
+      fail(`No webhook at ${path}`);
+    for (const { config } of matches) {
+      console.log(`${config.method} ${config.path}`);
+      for (const key of [
+        "params",
+        "query",
+        "headers",
+        "body",
+        "response"
+      ]) {
+        if (!config[key])
+          continue;
+        const json = jsonSchemaOf(config[key]);
+        console.log(`  ${key}: ${json ? JSON.stringify(json, null, 2).replaceAll(`
+`, `
+  `) : "(no JSON Schema support)"}`);
+      }
+    }
+    return;
+  }
+  if (command === "test") {
+    const [method, path] = args;
+    if (!method || !path)
+      fail("Usage: test <method> <path>");
+    const headers = new Headers;
+    for (const header of values.header ?? []) {
+      const at = header.indexOf(":");
+      if (at < 1)
+        fail(`Header must look like "name: value", got "${header}"`);
+      headers.set(header.slice(0, at).trim(), header.slice(at + 1).trim());
+    }
+    if (values.body && !headers.has("content-type")) {
+      try {
+        JSON.parse(values.body);
+        headers.set("content-type", "application/json");
+      } catch {
+        headers.set("content-type", "text/plain");
+      }
+    }
+    const url = `${path.startsWith("/") ? path : `/${path}`}${values.query ? `?${values.query}` : ""}`;
+    const start = performance.now();
+    const res = await app.request(url, {
+      method: method.toUpperCase(),
+      headers,
+      body: values.body
+    });
+    const text = await res.text();
+    let body = text;
+    try {
+      body = JSON.stringify(JSON.parse(text), null, 2);
+    } catch {}
+    console.log(`${res.status} (${(performance.now() - start).toFixed(1)}ms)`);
+    if (body)
+      console.log(body);
+    if (!res.ok)
+      process.exitCode = 1;
+    return;
+  }
+  fail(`Unknown command: ${command}
+
+${HELP}`);
+}
+await main();

package/dist/index.d.ts

@@ -0,0 +1,143 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import { type Context, type Env, Hono } from 'hono';
+import { HTTPException } from 'hono/http-exception';
+import type { ParamKeys, ParamKeyToRecord } from 'hono/types';
+export type { StandardSchemaV1 };
+/** HEAD is not listed: Hono answers HEAD requests with the matching GET route. */
+export type WebhookMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS';
+/**
+ * How the request body is parsed before validation.
+ * - `auto` (default): by `Content-Type`. JSON types are parsed as JSON,
+ *   `application/x-www-form-urlencoded` as a string record, anything else as text.
+ * - `json`, `form`, `text`: always parse that way, whatever the header says.
+ */
+export type BodyType = 'auto' | 'json' | 'form' | 'text';
+/** The part of the request (or the response) a schema validates. */
+export type ValidationTarget = 'params' | 'query' | 'headers' | 'body' | 'response';
+type Schema = StandardSchemaV1;
+type Out<S, Fallback> = S extends Schema ? StandardSchemaV1.InferOutput<S> : Fallback;
+type MaybePromise<T> = T | Promise<T>;
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/**
+ * Params typed from the path string: `/users/:id` gives `{ id: string }`,
+ * `/files/:name?` gives `{ name: string | undefined }`.
+ */
+export type PathParams<P extends string> = [ParamKeys<P>] extends [never] ? Record<string, never> : UnionToIntersection<ParamKeyToRecord<ParamKeys<P>>>;
+export interface WebhookConfig<P extends string = string, TParams extends Schema | undefined = Schema | undefined, TQuery extends Schema | undefined = Schema | undefined, THeaders extends Schema | undefined = Schema | undefined, TBody extends Schema | undefined = Schema | undefined, TResponse extends Schema | undefined = Schema | undefined> {
+    method: WebhookMethod;
+    /** Hono path pattern, relative to where the webhooks are mounted. */
+    path: P;
+    params?: TParams;
+    query?: TQuery;
+    /** Header names are lower-case. */
+    headers?: THeaders;
+    body?: TBody;
+    /**
+     * Checks what the handler returns. A mismatch is reported on
+     * `WebhookEvent.validation` and the response is still sent.
+     */
+    response?: TResponse;
+    /** @default 'auto' */
+    bodyType?: BodyType;
+    /** Shown by the CLI. */
+    description?: string;
+}
+export interface WebhookInput<E extends Env, P extends string, TParams, TQuery, THeaders, TBody> {
+    /** The Hono context: `c.env`, `c.var`, `c.header()`, `c.req.raw`, ... */
+    c: Context<E, P>;
+    params: Out<TParams, PathParams<P>>;
+    query: Out<TQuery, Record<string, string>>;
+    headers: Out<THeaders, Record<string, string>>;
+    /** `undefined` for an empty body when there is no body schema. */
+    body: Out<TBody, unknown>;
+    /** The body exactly as received, for signature verification. */
+    rawBody: string;
+}
+/**
+ * What a handler may return: a `Response` is sent as is, `undefined` becomes
+ * `204 No Content`, a string is sent as text and anything else as JSON.
+ */
+export type WebhookResult<TResponse> = MaybePromise<Response | (TResponse extends Schema ? Out<TResponse, never> : unknown)>;
+export interface Webhook<E extends Env = any, P extends string = string, TParams extends Schema | undefined = any, TQuery extends Schema | undefined = any, THeaders extends Schema | undefined = any, TBody extends Schema | undefined = any, TResponse extends Schema | undefined = any> {
+    config: WebhookConfig<P, TParams, TQuery, THeaders, TBody, TResponse>;
+    handler(input: WebhookInput<E, P, TParams, TQuery, THeaders, TBody>): WebhookResult<TResponse>;
+}
+/** Reported once per request that reaches the webhooks, after the response is built. */
+export interface WebhookEvent<E extends Env = any> {
+    c: Context<E>;
+    /** The matched path pattern, e.g. `/users/:id`. `undefined` for a 404. */
+    route: string | undefined;
+    method: string;
+    /** The requested path. */
+    path: string;
+    status: number;
+    durationMs: number;
+    /** Each part is set once it has been validated. */
+    params?: unknown;
+    query?: unknown;
+    headers?: unknown;
+    body?: unknown;
+    rawBody?: string;
+    /** What the handler returned, unless it returned a `Response`. */
+    response?: unknown;
+    /** Anything thrown: a `WebhookValidationError`, an `HTTPException` or a handler error. */
+    error?: unknown;
+    /** Set when validation failed, including a response that failed its schema. */
+    validation?: {
+        target: ValidationTarget;
+        issues: readonly StandardSchemaV1.Issue[];
+    };
+}
+export interface WebhooksOptions<E extends Env = any> {
+    /**
+     * Called after every request: log it, store it, record metrics. Not
+     * awaited; a returned promise is handed to `executionCtx.waitUntil` when
+     * the runtime has one, and its rejection is logged.
+     */
+    onEvent?: (event: WebhookEvent<E>) => MaybePromise<void>;
+    /**
+     * Turns an error into a response. Return nothing to use the default:
+     * `400 { error, issues }` for validation, the status of an `HTTPException`,
+     * and `500 { error: 'Internal Server Error' }` for anything else.
+     */
+    onError?: (error: unknown, c: Context<E>) => MaybePromise<Response | void>;
+}
+export type WebhooksApp<E extends Env = any> = Hono<E> & {
+    /** The definitions, in the order they were passed. */
+    readonly webhooks: readonly Webhook<E>[];
+};
+/** Thrown when a request part fails its schema. Answers 400 by default. */
+export declare class WebhookValidationError extends HTTPException {
+    readonly target: Exclude<ValidationTarget, 'response'>;
+    readonly issues: readonly StandardSchemaV1.Issue[];
+    constructor(target: Exclude<ValidationTarget, 'response'>, issues: readonly StandardSchemaV1.Issue[]);
+}
+/**
+ * Defines one webhook. Types for `params`, `query`, `headers`, `body` and the
+ * return value come from the schemas; `params` falls back to the path.
+ *
+ * @example
+ * defineWebhook(
+ *   { method: 'POST', path: '/orders/:id', body: z.object({ total: z.number() }) },
+ *   async ({ params, body }) => ({ id: params.id, total: body.total })
+ * )
+ */
+export declare const defineWebhook: <const P extends string, TParams extends Schema | undefined = undefined, TQuery extends Schema | undefined = undefined, THeaders extends Schema | undefined = undefined, TBody extends Schema | undefined = undefined, TResponse extends Schema | undefined = undefined>(config: WebhookConfig<P, TParams, TQuery, THeaders, TBody, TResponse>, handler: (input: WebhookInput<any, P, TParams, TQuery, THeaders, TBody>) => WebhookResult<TResponse>) => Webhook<any, P, TParams, TQuery, THeaders, TBody, TResponse>;
+/**
+ * Builds a Hono app that serves the webhooks. Mount it under a prefix:
+ * `app.route('/webhooks', createWebhooks([...]))`. Unknown paths below the
+ * prefix answer 404, known paths with the wrong method answer 405.
+ */
+export declare const createWebhooks: (webhooks: readonly Webhook<any, string, any, any, any, any, any>[], options?: WebhooksOptions<any>) => WebhooksApp<any>;
+/**
+ * `defineWebhook` and `createWebhooks` bound to your Hono `Env`, so handlers
+ * see typed `c.env` and `c.var`.
+ *
+ * @example
+ * export const { defineWebhook, createWebhooks } =
+ *   createWebhookFactory<{ Bindings: { STRIPE_SECRET: string } }>()
+ */
+export declare function createWebhookFactory<E extends Env = any>(): {
+    defineWebhook: <const P extends string, TParams extends Schema | undefined = undefined, TQuery extends Schema | undefined = undefined, THeaders extends Schema | undefined = undefined, TBody extends Schema | undefined = undefined, TResponse extends Schema | undefined = undefined>(config: WebhookConfig<P, TParams, TQuery, THeaders, TBody, TResponse>, handler: (input: WebhookInput<E, P, TParams, TQuery, THeaders, TBody>) => WebhookResult<TResponse>) => Webhook<E, P, TParams, TQuery, THeaders, TBody, TResponse>;
+    createWebhooks: (webhooks: readonly Webhook<E, string, any, any, any, any, any>[], options?: WebhooksOptions<E>) => WebhooksApp<E>;
+};

package/dist/index.js

@@ -0,0 +1,174 @@
+// src/index.ts
+import { Hono } from "hono";
+import { HTTPException } from "hono/http-exception";
+
+class WebhookValidationError extends HTTPException {
+  target;
+  issues;
+  constructor(target, issues) {
+    super(400, { message: `Invalid ${target}` });
+    this.target = target;
+    this.issues = issues;
+    this.name = "WebhookValidationError";
+  }
+}
+function makeDefineWebhook() {
+  return (config, handler) => ({
+    config,
+    handler
+  });
+}
+function detectBodyType(contentType = "") {
+  if (/[/+]json\b/i.test(contentType))
+    return "json";
+  if (/x-www-form-urlencoded/i.test(contentType))
+    return "form";
+  return "text";
+}
+function parseBody(raw, type, contentType) {
+  if (!raw)
+    return;
+  const resolved = type === "auto" ? detectBodyType(contentType) : type;
+  if (resolved === "text")
+    return raw;
+  if (resolved === "form")
+    return Object.fromEntries(new URLSearchParams(raw));
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new WebhookValidationError("body", [{ message: "Malformed JSON" }]);
+  }
+}
+async function parse(schema, value, target) {
+  if (!schema)
+    return value;
+  const result = await schema["~standard"].validate(value);
+  if (result.issues)
+    throw new WebhookValidationError(target, result.issues);
+  return result.value;
+}
+function defaultErrorResponse(error, c, log) {
+  if (error instanceof WebhookValidationError) {
+    return c.json({ error: error.message, issues: error.issues }, 400);
+  }
+  if (error instanceof HTTPException) {
+    return error.res ?? c.json({ error: error.message }, error.status);
+  }
+  if (log)
+    console.error(error);
+  return c.json({ error: "Internal Server Error" }, 500);
+}
+function report(c, pending) {
+  if (!(pending instanceof Promise))
+    return;
+  const handled = pending.catch((error) => console.error("hono-webhooks: onEvent failed", error));
+  try {
+    c.executionCtx.waitUntil(handled);
+  } catch {}
+}
+function isDynamic(path) {
+  return path.includes(":") || path.includes("*");
+}
+function makeCreateWebhooks() {
+  return (webhooks, options = {}) => {
+    const app = new Hono;
+    const methodsByPath = new Map;
+    for (const { config } of webhooks) {
+      const methods = methodsByPath.get(config.path) ?? [];
+      if (methods.includes(config.method)) {
+        throw new Error(`hono-webhooks: ${config.method} ${config.path} is defined twice`);
+      }
+      methods.push(config.method);
+      methodsByPath.set(config.path, methods);
+    }
+    const handle = (route, run) => {
+      return async (c) => {
+        const start = performance.now();
+        const event = {
+          c,
+          route,
+          method: c.req.method,
+          path: c.req.path,
+          status: 0,
+          durationMs: 0
+        };
+        let res;
+        try {
+          res = await run(c, event);
+        } catch (error) {
+          event.error = error;
+          if (error instanceof WebhookValidationError) {
+            event.validation = { target: error.target, issues: error.issues };
+          }
+          res = await options.onError?.(error, c) ?? defaultErrorResponse(error, c, !options.onError);
+        }
+        event.status = res.status;
+        event.durationMs = performance.now() - start;
+        if (options.onEvent)
+          report(c, options.onEvent(event));
+        return res;
+      };
+    };
+    const ordered = [...webhooks].sort((a, b) => Number(isDynamic(a.config.path)) - Number(isDynamic(b.config.path)));
+    for (const { config, handler } of ordered) {
+      app.on(config.method, config.path, handle(config.path, async (c, event) => {
+        event.params = await parse(config.params, c.req.param(), "params");
+        event.query = await parse(config.query, c.req.query(), "query");
+        event.headers = await parse(config.headers, c.req.header(), "headers");
+        event.rawBody = await c.req.text();
+        event.body = await parse(config.body, parseBody(event.rawBody, config.bodyType ?? "auto", c.req.header("content-type")), "body");
+        const result = await handler({
+          c,
+          params: event.params,
+          query: event.query,
+          headers: event.headers,
+          body: event.body,
+          rawBody: event.rawBody
+        });
+        if (result instanceof Response)
+          return result;
+        event.response = result;
+        if (config.response) {
+          const checked = await config.response["~standard"].validate(result);
+          if (checked.issues) {
+            event.validation = { target: "response", issues: checked.issues };
+          }
+        }
+        if (result === undefined)
+          return c.body(null, 204);
+        if (typeof result === "string") {
+          return c.text(result, 200, {
+            "content-type": "text/plain; charset=UTF-8"
+          });
+        }
+        return c.json(result);
+      }));
+    }
+    for (const [path, methods] of methodsByPath) {
+      app.all(path, handle(path, async (c) => {
+        c.header("Allow", methods.join(", "));
+        throw new HTTPException(405, {
+          message: `Method ${c.req.method} not allowed`
+        });
+      }));
+    }
+    app.all("*", handle(undefined, async () => {
+      throw new HTTPException(404, { message: "Route not found" });
+    }));
+    return Object.assign(app, { webhooks });
+  };
+}
+var defineWebhook = makeDefineWebhook();
+var createWebhooks = makeCreateWebhooks();
+function createWebhookFactory() {
+  return {
+    defineWebhook: makeDefineWebhook(),
+    createWebhooks: makeCreateWebhooks()
+  };
+}
+export {
+  WebhookValidationError,
+  createWebhookFactory,
+  createWebhooks,
+  defineWebhook
+};

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "hono-webhooks",
+  "version": "0.1.0",
+  "description": "Type-safe webhook routes for Hono, validated with any Standard Schema library (Zod, Valibot, ArkType)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HansKristoffer/hono-webhooks.git"
+  },
+  "homepage": "https://github.com/HansKristoffer/hono-webhooks#readme",
+  "bugs": {
+    "url": "https://github.com/HansKristoffer/hono-webhooks/issues"
+  },
+  "author": "Kristoffer Hansen",
+  "keywords": [
+    "hono",
+    "webhooks",
+    "webhook",
+    "standard-schema",
+    "zod",
+    "valibot",
+    "arktype",
+    "typescript",
+    "type-safe"
+  ],
+  "files": [
+    "src/**/*.ts",
+    "dist",
+    "!src/**/*.test.ts"
+  ],
+  "sideEffects": false,
+  "bin": {
+    "hono-webhooks": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf dist && bun run build:js && bun run build:types",
+    "build:js": "bun build ./src/index.ts ./src/cli.ts --outdir ./dist --target node --packages external",
+    "build:types": "tsgo -p tsconfig.build.json",
+    "prepublishOnly": "bun run build",
+    "test": "bun test",
+    "lint": "bun run typecheck && bun biome check",
+    "lint:write": "bun run typecheck && bun biome check --write",
+    "typecheck": "tsgo --noEmit",
+    "prepare": "husky"
+  },
+  "dependencies": {
+    "@standard-schema/spec": "^1.1.0"
+  },
+  "peerDependencies": {
+    "hono": "^4.6.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.5.14",
+    "@types/bun": "^1.4.2",
+    "@typescript/native-preview": "^7.0.0-dev.20260707.2",
+    "hono": "^4.13.10",
+    "husky": "^9.1.7",
+    "typescript": "^7.0.2",
+    "valibot": "^1.5.0",
+    "zod": "^4.6.5"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+import { resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { parseArgs } from 'node:util'
+import type { StandardJSONSchemaV1 } from '@standard-schema/spec'
+import type { WebhooksApp } from './index'
+
+const HELP = `Usage: hono-webhooks <module> <command> [options]
+
+<module> exports the result of createWebhooks(), as default or named export.
+
+Commands:
+  list                      List the webhooks
+  schema <path>             Print the JSON Schemas of the webhooks at <path>
+  test <method> <path>      Send a request through the webhooks app
+
+Options for test:
+  -b, --body <text>         Request body (JSON sets content-type: application/json)
+  -q, --query <params>      Query string, e.g. "a=1&b=2"
+  -H, --header <k: v>       Request header, repeatable
+
+Examples:
+  hono-webhooks ./src/webhooks.ts list
+  hono-webhooks ./src/webhooks.ts schema /orders/:id
+  hono-webhooks ./src/webhooks.ts test POST /orders/42 -b '{"total":10}'
+`
+
+const { values, positionals } = parseArgs({
+	allowPositionals: true,
+	options: {
+		help: { type: 'boolean', short: 'h' },
+		body: { type: 'string', short: 'b' },
+		query: { type: 'string', short: 'q' },
+		header: { type: 'string', short: 'H', multiple: true }
+	}
+})
+
+const [modulePath, command, ...args] = positionals
+
+function fail(message: string): never {
+	console.error(message)
+	process.exit(1)
+}
+
+function isWebhooksApp(value: unknown): value is WebhooksApp {
+	return (
+		typeof value === 'object' &&
+		value !== null &&
+		Array.isArray((value as WebhooksApp).webhooks) &&
+		typeof (value as WebhooksApp).request === 'function'
+	)
+}
+
+async function loadApp(path: string) {
+	const mod = await import(pathToFileURL(resolve(path)).href)
+	const app = [mod.default, ...Object.values(mod)].find(isWebhooksApp)
+	return app ?? fail(`${path} does not export a createWebhooks() app`)
+}
+
+function jsonSchemaOf(schema: unknown) {
+	const props = (schema as Partial<StandardJSONSchemaV1>)['~standard']
+	try {
+		return props?.jsonSchema?.input({ target: 'draft-2020-12' })
+	} catch {
+		return undefined
+	}
+}
+
+async function main() {
+	if (values.help || !modulePath || !command) {
+		console.log(HELP)
+		return
+	}
+	const app = await loadApp(modulePath)
+
+	if (command === 'list') {
+		for (const { config } of app.webhooks) {
+			const validates = (['params', 'query', 'headers', 'body'] as const)
+				.filter((key) => config[key])
+				.join(', ')
+			console.log(
+				`${config.method.padEnd(7)} ${config.path}${config.description ? `  ${config.description}` : ''}`
+			)
+			if (validates) console.log(`        validates ${validates}`)
+		}
+		return
+	}
+
+	if (command === 'schema') {
+		const [path] = args
+		const matches = app.webhooks.filter((w) => w.config.path === path)
+		if (!matches.length) fail(`No webhook at ${path}`)
+		for (const { config } of matches) {
+			console.log(`${config.method} ${config.path}`)
+			for (const key of [
+				'params',
+				'query',
+				'headers',
+				'body',
+				'response'
+			] as const) {
+				if (!config[key]) continue
+				const json = jsonSchemaOf(config[key])
+				console.log(
+					`  ${key}: ${json ? JSON.stringify(json, null, 2).replaceAll('\n', '\n  ') : '(no JSON Schema support)'}`
+				)
+			}
+		}
+		return
+	}
+
+	if (command === 'test') {
+		const [method, path] = args
+		if (!method || !path) fail('Usage: test <method> <path>')
+		const headers = new Headers()
+		for (const header of values.header ?? []) {
+			const at = header.indexOf(':')
+			if (at < 1) fail(`Header must look like "name: value", got "${header}"`)
+			headers.set(header.slice(0, at).trim(), header.slice(at + 1).trim())
+		}
+		if (values.body && !headers.has('content-type')) {
+			try {
+				JSON.parse(values.body)
+				headers.set('content-type', 'application/json')
+			} catch {
+				headers.set('content-type', 'text/plain')
+			}
+		}
+
+		const url = `${path.startsWith('/') ? path : `/${path}`}${values.query ? `?${values.query}` : ''}`
+		const start = performance.now()
+		const res = await app.request(url, {
+			method: method.toUpperCase(),
+			headers,
+			body: values.body
+		})
+		const text = await res.text()
+		let body = text
+		try {
+			body = JSON.stringify(JSON.parse(text), null, 2)
+		} catch {}
+		console.log(`${res.status} (${(performance.now() - start).toFixed(1)}ms)`)
+		if (body) console.log(body)
+		if (!res.ok) process.exitCode = 1
+		return
+	}
+
+	fail(`Unknown command: ${command}\n\n${HELP}`)
+}
+
+await main()