Generated banner for Nitro
Generated logo for Nitro

Nitro

Anthony FuCommunityCreated by Anthony Fu

  • Skill
  • Tool integration
  • Software development
  • MIT
  • No issues found

From the author

Nitro is the framework-agnostic server toolkit (powering Nuxt) for building and deploying web servers anywhere. Use when working with nitro.config, server routes/event handlers, route rules, caching, storage, tasks, websockets, or deploying to Node/Bun/Deno/Cloudflare/Vercel.
— the description by Anthony Fu

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

Nitro is a server toolkit designed to build and deploy web servers that run on Node.js, Bun, Deno, and various cloud platforms like Cloudflare, Vercel, and Netlify. It provides a unified codebase for server development, featuring filesystem-based routing, a built-in KV storage layer, caching mechanisms, and support for tasks, WebSockets, and OpenAPI documentation. Nitro v3 introduces significant changes including a package rename, the removal of auto-imports, and a shift toward web-standard H3 v2 APIs.

What it does

  • Provides filesystem-based routing with H3 v2 event handlers.
  • Manages server configuration and runtime settings via nitro.config.ts.
  • Handles caching and storage using an unstorage-based KV layer.
  • Supports on-demand and scheduled tasks, WebSockets, and SSE.
  • Generates OpenAPI specifications automatically from route metadata.
  • Enables deployment to multiple runtimes and platforms through presets.

When to use it

  • When building a web server that needs to be portable across different deployment environments.
  • When you require a unified toolkit for handling routing, storage, and caching in a server project.
  • When migrating existing server projects from Nitro v2 to v3.
  • When you need to implement server-side tasks, WebSockets, or OpenAPI documentation.

Advantages

  • Framework-agnostic design allows for use with or without other frameworks.
  • Deployment-agnostic architecture supports a wide range of runtimes and cloud providers.
  • Unified storage and caching layer simplifies data management.
  • Declarative route rules for handling redirects, headers, and CORS.
  • Built-in support for modern web standards via H3 v2.

Usage examples

“How do I define a basic server route in Nitro v3?”
You create a file in your server directory and export a handler using defineHandler from the nitro package.
“How do I access KV storage in my Nitro server?”
You use the useKV function imported from nitro/kv to interact with your configured storage mount points.
“What is the correct way to import Nitro utilities in v3?”
You must use explicit imports from specific subpaths like nitro, nitro/kv, or nitro/h3, as auto-imports are no longer supported.
“How do I configure public assets in Nitro?”
You define a publicAssets array in your nitro.config.ts file, specifying the directory and base URL for your assets.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/antfu/nitro/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip nitro.zip -d .agents/skills

Documentation by Anthony Fu

The skill is based on Nitro v3 (beta, 3.0.260903), generated at 2026-09-25.

Nitro is a framework-agnostic, deployment-agnostic server toolkit powered by H3 v2, unstorage, and Vite/Rolldown/Rollup. It powers Nuxt and works standalone. From one codebase it builds optimized output for Node.js, Bun, Deno, Cloudflare, Vercel, Netlify, and more.

Key capabilities:

  • Filesystem routing with H3 v2 event handlers, dynamic params, and method suffixes.

  • Route rules for declarative caching, headers, redirects, proxying, and CORS.

  • Caching layer (cached handlers/functions, SWR) on top of the unstorage KV layer.

  • Runtime config overridable via NITRO_* env vars.

  • Tasks (on-demand + scheduled/cron), WebSockets/SSE, a SQL database layer, and OpenAPI auto-docs.

  • Plugins & lifecycle hooks, custom renderer/server entry, and portable deployment presets.

Key v3 changes (vs. nitropack v2): the package is renamed nitropack → nitro with H3 v2 (web-standard Request/Response); auto-imports are removed (import everything explicitly); directory scanning is opt-in via serverDir; useStorage → useKV (nitro/kv) and the storage config option → kv; cache swr now defaults to false. If unsure about v2-vs-v3 APIs, read advanced-migration first.

Core

TopicDescriptionReference
RoutingFile-based routes, defineHandler, params, middleware, route rules, errorscore-routing
Configurationnitro.config.ts, defineConfig, key options, runtime configcore-configuration
Storageunstorage KV, mount points, drivers, dynamic mountscore-storage
CachedefineCachedHandler, defineCachedFunction, SWR, invalidationcore-cache
AssetsPublic assets, compression, server assets via storagecore-assets
RenderingRenderer (HTML/SSR), server entry, framework integrationcore-rendering

Features

TopicDescriptionReference
Plugins & HooksdefinePlugin, runtime lifecycle hooks, error capturefeatures-plugins
TasksOn-demand & scheduled (cron) tasks, runTaskfeatures-tasks
WebSocket & SSEdefineWebSocketHandler, pub/sub, namespaces, event streamsfeatures-websocket
DatabaseBuilt-in SQL layer via db0, useDatabase, connectorsfeatures-database
OpenAPIAuto spec from defineRouteMeta, Scalar/Swagger UIsfeatures-openapi

Advanced / Deployment

TopicDescriptionReference
Deployment PresetsRuntimes & providers, compatibility dates, platform integrationdeploy-presets
v2 → v3 MigrationPackage rename, nitro/* imports, H3 v2 API, preset changesadvanced-migration

Files

references/features-plugins.md


name: plugins description: Nitro plugins, runtime lifecycle hooks, error capture, and request/response handling

Plugins & Lifecycle Hooks

Nitro plugins run once at server startup to extend runtime behavior. They are auto-registered from plugins/ (by filename order) and receive the nitroApp context. Import definePlugin from nitro.

import { definePlugin } from "nitro";

export default definePlugin((nitroApp) => {
  console.log("Nitro starting");
});

v3 renamed defineNitroPlugin → definePlugin. The plugin function itself must be synchronous (return void); the hooks it registers may be async. Register external plugins with the plugins: ["~/plugins/x.ts"] config option.

The nitroApp context

PropertyDescription
hookshookable instance to register lifecycle callbacks.
h3The underlying H3 app instance.
fetch(req)The app's internal fetch handler.
captureError(error, ctx)Feed errors into the error hook pipeline.

Runtime hooks

Register lifecycle callbacks inside a plugin. hook() returns an unregister function.

HookSignatureWhen
request(event) => void | PromiseStart of each request, before routing.
response(res: Response, event) => void | PromiseAfter the response is created.
error(error, { event?, tags? }) => voidWhen any error is captured.
close() => voidOn server shutdown.
import { definePlugin } from "nitro";

export default definePlugin((nitroApp) => {
  nitroApp.hooks.hook("request", (event) => {
    console.log("→", event.path);
  });

  nitroApp.hooks.hook("response", (res, event) => {
    const { pathname } = new URL(event.req.url);
    if (pathname.endsWith(".js")) res.headers.append("Vary", "Origin");
  });

  nitroApp.hooks.hook("close", async () => {
    // clean up DB connections, timers, etc.
  });
});

The request hook is the very first code per request (errors there are captured, not fatal). The response hook runs for every response, including static assets and errors. On shutdown the server waits for pending event.waitUntil tasks.

Error capture

import { definePlugin } from "nitro";

export default definePlugin((nitroApp) => {
  nitroApp.hooks.hook("error", (error, { event, tags }) => {
    console.error(`[${tags?.join(",")}] ${event?.path}`, error);
  });

  // Manually report
  nitroApp.captureError(new Error("startup issue"), { tags: ["startup"] });
});

tags identify the source: "request", "response", "cache", "plugin", "unhandledRejection", "uncaughtException". Process-level unhandled rejections and uncaught exceptions are auto-captured into the error hook.

Notes

  • features.runtimeHooks is auto-enabled when at least one plugin exists; force with features.runtimeHooks: true.

  • NitroRuntimeHooks is augmentable — presets add platform hooks (e.g. Cloudflare cloudflare:scheduled, cloudflare:email; Vercel vercel:queue).

  • useNitroApp, useNitroHooks, and getRouteRules are imported from nitro/app (no auto-imports in v3). Outside plugins, prefer useNitroHooks() over useNitroApp().hooks to guarantee a hooks instance.

  • The hook() method returns an unregister function.

  • For internal requests to your own server, use serverFetch from nitro (v2 localFetch is gone).

Key Points

  • Plugins run once at startup; use them to init resources and register hooks.

  • Import definePlugin from nitro (not defineNitroPlugin); useNitroApp/useNitroHooks from nitro/app.

  • Use request/response/error/close hooks for cross-cutting runtime behavior.

  • Customize response headers in the response hook via res.headers.

<!-- Source references: - https://nitro.build/docs/plugins - https://nitro.build/docs/lifecycle -->

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Anthony Fu
Publisher
Anthony Fu (Community)
Source
antfu/skills · skills/nitro · commit f63e9ec
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE.md)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Anthony Fu.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download nitro.zip