菜单
Use when building Hono web applications or when the user asks about Hono APIs, routing, middleware, JSX, validation, testing, or streaming. TRIGGER when code imports from 'hono' or 'hono/*', or user mentions Hono. Use `npx hono request` to test endpoints.
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/arvindrk/twitter-agent --skill hono命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
正在显示 SKILL.md
基于 SOC 职业分类
| name | hono |
| description | Use when building Hono web applications or when the user asks about Hono APIs, routing, middleware, JSX, validation, testing, or streaming. TRIGGER when code imports from 'hono' or 'hono/*', or user mentions Hono. Use `npx hono request` to test endpoints. |
Build Hono web applications. This skill provides inline API knowledge for AI. Use npx hono request to test endpoints. If the hono-docs MCP server is configured, prefer its tools for the latest documentation over the inline reference.
Test endpoints without starting an HTTP server. Uses app.request() internally.
# GET request
npx hono request [file] -P /path
# POST request with JSON body
npx hono request [file] -X POST -P /api/users -d '{"name": "test"}'
Note: Do not pass credentials directly in CLI arguments. Use environment variables for sensitive values. hono request does not support Cloudflare Workers bindings (KV, D1, R2, etc.). When bindings are required, use workers-fetch instead:
npx workers-fetch /path
npx workers-fetch -X POST -H "Content-Type:application/json" -d '{"name":"test"}' /api/users
import { Hono } from "hono";
const app = new Hono();
// With TypeScript generics
type Env = {
Bindings: { DATABASE: D1Database; KV: KVNamespace };
Variables: { user: User };
};
const app = new Hono<Env>();
app.get("/path", handler);
app.post("/path", handler);
app.put("/path", handler);
app.delete("/path", handler);
app.patch("/path", handler);
app.options("/path", handler);
app.all("/path", handler); // all HTTP methods
app.on("PURGE", "/path", handler); // custom method
app.on(["PUT", "DELETE"], "/path", handler); // multiple methods
// Path parameters
app.get("/user/:name", (c) => {
const name = c.req.param("name");
return c.json({ name });
});
// Multiple params
app.get("/posts/:id/comments/:commentId", (c) => {
const { id, commentId } = c.req.param();
});
// Optional parameters
app.get("/api/animal/:type?", (c) => c.text("Animal!"));
// Wildcards
app.get("/wild/*/card", (c) => c.text("Wildcard"));
// Regexp constraints
app.get("/post/:date{[0-9]+}/:title{[a-z]+}", (c) => {
const { date, title } = c.req.param();
});
// Chained routes
app.get("/endpoint", (c) => c.text("GET"))
.post((c) => c.text())
.( c.());
// Using route()
const api = new Hono();
api.get("/users", (c) => c.json([]));
const app = new Hono();
app.route("/api", api); // mounts at /api/users
// Using basePath()
const app = new Hono().basePath("/api");
app.get("/users", (c) => c.json([])); // GET /api/users
app.notFound((c) => c.json({ message: "Not Found" }, 404));
app.onError((err, c) => {
console.error(err);
return c.json({ message: "Internal Server Error" }, 500);
});
c.text("Hello"); // text/plain
c.json({ message: "Hello" }); // application/json
c.html("<h1>Hello</h1>"); // text/html
c.redirect("/new-path"); // 302 redirect
c.redirect("/new-path", 301); // 301 redirect
c.body("raw body", 200, headers); // raw response
c.notFound(); // 404 response
c.status(201);
c.header("X-Custom", "value");
c.header("Cache-Control", "no-store");
// In middleware
c.set("user", { id: 1, name: "Alice" });
// In handler
const user = c.get("user");
// or
const user = c.var.user;
const value = await c.env.KV.get("key");
const db = c.env.DATABASE;
c.executionCtx.waitUntil(promise);
app.use(async (c, next) => {
c.setRenderer((content) =>
c.html(
<html><body>{content}</body></html>
)
)
await next()
})
app.get('/', (c) => c.render(<h1>Hello</h1>))
c.req.param("id"); // path parameter
c.req.param(); // all path params as object
c.req.query("page"); // query string parameter
c.req.query(); // all query params as object
c.req.queries("tags"); // multiple values: ?tags=A&tags=B → ['A', 'B']
c.req.header("Authorization"); // request header
c.req.header(); // all headers (keys are lowercase)
// Body parsing
await c.req.json(); // parse JSON body
await c.req.text(); // parse text body
await c.req.formData(); // parse as FormData
await c.req.parseBody(); // parse multipart/form-data or urlencoded
await c.req.arrayBuffer(); // parse as ArrayBuffer
await c.req.blob(); // parse as Blob
c..();
c..();
c..();
c..();
c..;
c..;
c..;
c..;
import { cors } from "hono/cors";
import { logger } from "hono/logger";
import { basicAuth } from "hono/basic-auth";
import { prettyJSON } from "hono/pretty-json";
import { secureHeaders } from "hono/secure-headers";
import { etag } from "hono/etag";
import { compress } from "hono/compress";
import { poweredBy } from "hono/powered-by";
import { timing } from "hono/timing";
import { cache } from "hono/cache";
import { bearerAuth } from "hono/bearer-auth";
import { jwt } from "hono/jwt";
import { csrf } from "hono/csrf";
import { ipRestriction } from "hono/ip-restriction";
import { bodyLimit } from "hono/body-limit";
import { requestId } from "hono/request-id";
import { methodOverride } from "hono/method-override";
{ trailingSlash, trimTrailingSlash } ;
app.(());
app.(, ());
app.(, ({ : , : }));
// Inline
app.use(async (c, next) => {
const start = Date.now();
await next();
const elapsed = Date.now() - start;
c.res.headers.set("X-Response-Time", `${elapsed}ms`);
});
// Reusable with createMiddleware
import { createMiddleware } from "hono/factory";
const auth = createMiddleware(async (c, next) => {
const token = c.req.header("Authorization");
if (!token) return c.json({ error: "Unauthorized" }, 401);
await next();
});
app.use("/api/*", auth);
Middleware executes in registration order. await next() calls the next middleware/handler, and code after next() runs on the way back:
Request → mw1 before → mw2 before → handler → mw2 after → mw1 after → Response
app.use(async (c, next) => {
// before handler
await next();
// after handler
});
Validation targets: json, form, query, header, param, cookie.
import { zValidator } from "@hono/zod-validator";
import { z } from "zod";
const schema = z.object({
title: z.string().min(1),
body: z.string(),
});
app.post("/posts", zValidator("json", schema), (c) => {
const data = c.req.valid("json"); // fully typed
return c.json(data, 201);
});
import { sValidator } from "@hono/standard-validator";
import * as v from "valibot";
const schema = v.object({ name: v.string(), age: v.number() });
app.post("/users", sValidator("json", schema), (c) => {
const data = c.req.valid("json");
return c.json(data, 201);
});
In tsconfig.json:
{
"compilerOptions": {
"jsx": "react-jsx",
"jsxImportSource": "hono/jsx"
}
}
Or use pragma: /** @jsxImportSource hono/jsx */
Important: Files using JSX must have a .tsx extension. Rename .ts to .tsx or the compiler will fail.
import type { PropsWithChildren } from "hono/jsx";
const Layout = (props: PropsWithChildren) => (
<html>
<head>
<title>My App</title>
</head>
<body>{props.children}</body>
</html>
);
const UserCard = ({ name }: { name: string }) => (
<div class="card">
<h2>{name}</h2>
</div>
);
app.get("/", (c) => {
return c.html(
<Layout>
<UserCard name="Alice" />
</Layout>,
);
});
Use jsxRenderer middleware for layouts. See npx hono docs /docs/middleware/builtin/jsx-renderer for details.
const UserList = async () => {
const users = await fetchUsers();
return (
<ul>
{users.map((u) => (
<li>{u.name}</li>
))}
</ul>
);
};
const Items = () => (
<>
<li>Item 1</li>
<li>Item 2</li>
</>
);
import { stream, streamText, streamSSE } from "hono/streaming";
// Basic stream
app.get("/stream", (c) => {
return stream(c, async (stream) => {
stream.onAbort(() => console.log("Aborted"));
await stream.write(new Uint8Array([0x48, 0x65]));
await stream.pipe(readableStream);
});
});
// Text stream
app.get("/stream-text", (c) => {
return streamText(c, async (stream) => {
await stream.writeln("Hello");
await stream.sleep(1000);
await stream.write("World");
});
});
// Server-Sent Events
app.get("/sse", (c) => {
return streamSSE(c, async (stream) => {
let id = 0;
() {
stream.({
: .({ : ().() }),
: ,
: (id++),
});
stream.();
}
});
});
Test endpoints without starting an HTTP server:
// GET
const res = await app.request("/posts");
expect(res.status).toBe(200);
expect(await res.json()).toEqual({ posts: [] });
// POST with JSON
const res = await app.request("/posts", {
method: "POST",
body: JSON.stringify({ title: "Hello" }),
headers: { "Content-Type": "application/json" },
});
// POST with FormData
const formData = new FormData();
formData.append("name", "Alice");
const res = await app.request("/users", { method: "POST", body: formData });
// With mock env (Cloudflare Workers bindings)
const res = await app.request(
"/api/data",
{},
{ KV: mockKV, DATABASE: mockDB },
);
// Using Request object
const req = (, { : });
res = app.(req);
Type-safe API client using shared types between server and client.
IMPORTANT: Routes MUST be chained for type inference to work. Without chaining, the client cannot infer route types.
// Server: routes MUST be chained to preserve types
const route = app
.post("/posts", zValidator("json", schema), (c) => {
return c.json({ ok: true }, 201);
})
.get("/posts", (c) => {
return c.json({ posts: [] });
});
export type AppType = typeof route;
// Client: use hc() with the exported type
import { hc } from "hono/client";
import type { AppType } from "./server";
const client = hc<AppType>("http://localhost:8787/");
const res = await client.posts.$post({ json: { title: "Hello" } });
const data = await res.json(); // fully typed
Type utilities:
import type { InferRequestType, InferResponseType } from "hono/client";
type ReqType = InferRequestType<typeof client.posts.$post>;
type ResType = InferResponseType<typeof client.posts.$post, 200>;
Helpers are utility functions imported from hono/<helper-name>:
import { getConnInfo } from "hono/conninfo";
import { getCookie, setCookie, deleteCookie } from "hono/cookie";
import { css, Style } from "hono/css";
import { createFactory } from "hono/factory";
import { html, raw } from "hono/html";
import { stream, streamText, streamSSE } from "hono/streaming";
import { testClient } from "hono/testing";
import { upgradeWebSocket } from "hono/cloudflare-workers"; // or other adapter
Available helpers: Accepts, Adapter, ConnInfo, Cookie, css, Dev, Factory, html, JWT, Proxy, Route, SSG, Streaming, Testing, WebSocket.
For details, use npx hono docs /docs/helpers/<helper-name>.
Use createFactory to define Env once and share it across app, middleware, and handlers:
import { createFactory } from "hono/factory";
const factory = createFactory<Env>();
// Create app (Env type is inherited)
const app = factory.createApp();
// Create middleware (Env type is inherited, no need to pass generics)
const mw = factory.createMiddleware(async (c, next) => {
await next();
});
// Create handlers separately (preserves type inference)
const handlers = factory.createHandlers(logger(), (c) =>
c.json({ message: "Hello" }),
);
app.get("/api", ...handlers);
app.route() to organize large apps by feature, not Rails-style controllers.createFactory() to share Env type across app, middleware, and handlers.c.set()/c.get() to pass data between middleware and handlers.export type AppType = typeof routesapp.request() for testing — no server startup needed.Hono runs on multiple runtimes. The default export works for Cloudflare Workers, Deno, and Bun. For Node.js, use the Node adapter:
// Cloudflare Workers / Deno / Bun
export default app;
// Node.js
import { serve } from "@hono/node-server";
serve(app);