n2n-post2site 0.1.2

package/.env.example

@@ -0,0 +1,2 @@
+CONTENT_API_BASE_URL=https://example.com/api/v1/mcp
+CONTENT_API_KEY=change-me

package/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+All notable changes to N2N Post2Site are documented in this file.
+
+## [0.1.2] - 2026-06-15
+
+### Added
+
+- Added `n2n_get_product_context` for reading a controlled product fact sheet before drafting product guides.
+- Documented the required product context fields: `content_scope`, `canonical_url`, `docs_url`, `summary`, `key_points`, and `do_not_claim`.
+- Added client and schema coverage for product context lookups.
+
+### Changed
+
+- Product guide creation guidance now requires reading product context before drafting.
+- Content creation guidance now requires searching existing posts first, and update guidance requires reading the target post first.
+- Clarified that create/update must not send publication governance fields such as `status`, `published_at`, `user_id`, or `author`; publishing remains a separate explicit tool call.
+- Version bumped to `0.1.2`.
+
+## [0.1.1] - 2026-06-15
+
+### Changed
+
+- Switched create and update inputs to a single-locale model with flat `locale`, `title`, `excerpt`, and `content` fields.
+- Removed create/update exposure for direct publication fields from the MCP schema.
+- Documented `missing_locales` and `next_actions` follow-up flow.
+
+## [0.1.0] - 2026-06-14
+
+### Added
+
+- Initial local MCP server for AI-assisted content publishing.
+- Tools for capabilities, listing posts, reading posts, creating drafts, updating drafts, and publishing posts.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Datafrog LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,352 @@
+# N2N Post2Site
+
+AI-assisted content publishing MCP server for blogs and product guides.
+
+[![npm version](https://img.shields.io/npm/v/n2n-post2site)](https://www.npmjs.com/package/n2n-post2site)
+[![npm total downloads](https://img.shields.io/npm/dt/n2n-post2site)](https://www.npmjs.com/package/n2n-post2site)
+[![license](https://img.shields.io/github/license/n2ns/n2n-post2site)](https://github.com/n2ns/n2n-post2site/blob/main/LICENSE)
+[![MCP Protocol](https://img.shields.io/badge/MCP-Protocol-blue)](https://modelcontextprotocol.io)
+[![node version](https://img.shields.io/node/v/n2n-post2site)](https://nodejs.org)
+[![DataFrog.io](https://datafrog.io/badges/datafrog.svg)](https://datafrog.io)
+
+N2N Post2Site lets an AI assistant draft, edit, review, and publish website content through a narrow Content Publishing API Contract. It is built for teams that want AI-assisted blog posts, technical notes, changelogs, and product guides without giving the assistant database access, shell access, deployment access, payment access, or user administration access.
+
+It is intentionally small: a local MCP bridge between your IDE assistant and your website content API. Your website remains responsible for authentication, validation, storage, preview, publishing rules, and audit behavior.
+
+## Quick summary
+
+- Runs locally as an MCP server.
+- Connects to one website content API through `CONTENT_API_BASE_URL` and `CONTENT_API_KEY`.
+- Creates drafts by default.
+- Publishes only through an explicit publish tool.
+- Submits one locale per create or update call.
+- Uses Markdown-first content, with optional inline HTML when your site supports it.
+- Reads product context before drafting product guides.
+- Does not expose database, shell, server, payment, user, pricing, or delete operations.
+
+## When to use it
+
+Use N2N Post2Site when you want an AI assistant to help with:
+
+- Company blog posts.
+- Product guides.
+- Technical field notes.
+- Release notes and changelogs.
+- Localized article drafts.
+- Safe updates to existing website content.
+
+Do not use it as a CMS. It does not provide an admin panel, database schema, storage backend, preview system, deployment workflow, or image upload service.
+
+## Publishing model
+
+N2N Post2Site works with two publishing spaces:
+
+| Space | `content_scope` | Example |
+|---|---|---|
+| Company blog | omitted or empty | technical notes, announcements, changelogs |
+| Product guide | `kind:key` | `product:evisa-helper` |
+
+The backend defines which scopes are valid. A product guide should only be written after the assistant reads controlled product context with `n2n_get_product_context`.
+
+The assistant should follow this workflow:
+
+1. Call `n2n_get_capabilities`.
+2. Search existing content with `n2n_list_posts`.
+3. For product guides, call `n2n_get_product_context`.
+4. Create or update one locale at a time.
+5. Review the draft.
+6. Publish only through `n2n_publish_post`.
+
+## Requirements
+
+- Node.js 22+
+- An MCP-capable client or IDE
+- A site-scoped content API token
+- A backend that implements the Content Publishing API Contract
+
+## Install
+
+For local development:
+
+```bash
+npm install
+npm run build
+npm run check
+```
+
+For MCP clients, use the published package after it is available on npm:
+
+```bash
+npx -y n2n-post2site
+```
+
+## Configuration
+
+Set these environment variables in your MCP client configuration:
+
+```env
+CONTENT_API_BASE_URL=https://example.com/api/v1/mcp
+CONTENT_API_KEY=change-me
+```
+
+`CONTENT_API_BASE_URL` is the base URL of your protected content API. The backend should expose `/capabilities`, `/products/{content_scope}`, and `/posts` relative to this base URL.
+
+Keep path mapping and field mapping in the backend adapter, not in MCP client configuration. The MCP config should only need a base URL and an API key.
+
+Do not put API keys in prompts, article content, README examples, or screenshots.
+
+## MCP client examples
+
+### Using the npm package
+
+```json
+{
+  "mcpServers": {
+    "n2n-post2site": {
+      "command": "npx",
+      "args": ["-y", "n2n-post2site"],
+      "env": {
+        "CONTENT_API_BASE_URL": "https://example.com/api/v1/mcp",
+        "CONTENT_API_KEY": "change-me"
+      }
+    }
+  }
+}
+```
+
+### Using a local checkout
+
+```json
+{
+  "mcpServers": {
+    "n2n-post2site": {
+      "command": "node",
+      "args": ["/path/to/n2n-post2site/dist/index.js"],
+      "env": {
+        "CONTENT_API_BASE_URL": "https://example.com/api/v1/mcp",
+        "CONTENT_API_KEY": "change-me"
+      }
+    }
+  }
+}
+```
+
+Bind one MCP server configuration to exactly one website. Do not ask the AI assistant to choose a `site_id` in tool arguments.
+
+## Backend API contract
+
+The backend should support these endpoints relative to `CONTENT_API_BASE_URL`:
+
+```http
+GET    /capabilities
+GET    /products/{content_scope}
+GET    /posts
+POST   /posts
+GET    /posts/{id_or_slug}
+PATCH  /posts/{id_or_slug}
+POST   /posts/{id_or_slug}/publish
+```
+
+### `GET /capabilities`
+
+Returns the publishing contract for AI clients, including:
+
+- Supported content types.
+- Supported statuses.
+- Supported locales.
+- Single-locale input fields.
+- `content_scope` rules.
+- Available product guide scopes.
+- Safety boundaries.
+
+### `GET /products/{content_scope}`
+
+Returns controlled product context before drafting product guides.
+
+Expected fields:
+
+- `content_scope`: confirms the valid product guide scope.
+- `canonical_url`: product page for deeper reading, links, and citations.
+- `docs_url`: docs or guide index to prefer for tutorials.
+- `summary`: controlled product summary.
+- `key_points`: controlled facts the assistant may rely on.
+- `do_not_claim`: claims the assistant must not make.
+
+### Create and update payloads
+
+Create and update calls use one locale per request:
+
+```json
+{
+  "slug": "example-product-guide",
+  "type": "guide",
+  "content_scope": "product:example-product",
+  "locale": "en",
+  "title": "How to Use Example Product",
+  "excerpt": "A short guide to using the example product.",
+  "content": "## Overview\n\nMarkdown content..."
+}
+```
+
+Rules:
+
+- `title` is plain text.
+- `excerpt` is plain text.
+- `content` is Markdown.
+- Inline HTML is allowed when useful.
+- Full HTML documents with `<html>`, `<head>`, or `<body>` are not allowed.
+- Create/update must not accept `status`, `published_at`, `user_id`, or `author`.
+- Publishing state changes only through `/posts/{id_or_slug}/publish`.
+
+Backends may return `missing_locales` and `next_actions` after create, update, or publish. The assistant should add missing language versions with additional `n2n_update_post` calls instead of asking the backend to auto-translate.
+
+## MCP tools
+
+### `n2n_get_capabilities`
+
+Read backend capabilities before creating or updating content.
+
+```json
+{}
+```
+
+### `n2n_list_posts`
+
+Search existing posts before drafting new content.
+
+```json
+{
+  "status": "draft",
+  "type": "guide",
+  "content_scope": "product:example-product",
+  "q": "setup guide",
+  "per_page": 20
+}
+```
+
+`status` is only a filter here. Do not send `status` in create or update calls.
+
+### `n2n_get_post`
+
+Read an existing post before updating it, completing missing locales, or writing a follow-up.
+
+```json
+{
+  "id_or_slug": "example-product-guide"
+}
+```
+
+### `n2n_get_product_context`
+
+Read controlled product facts before drafting a product guide.
+
+```json
+{
+  "content_scope": "product:example-product"
+}
+```
+
+### `n2n_create_post`
+
+Create a draft. Publishing is separate.
+
+Company blog example:
+
+```json
+{
+  "slug": "content-workflow-notes",
+  "type": "technical",
+  "locale": "en",
+  "title": "Content Workflow Notes",
+  "excerpt": "Practical notes from shipping a content workflow.",
+  "content": "## Notes\n\nMarkdown content..."
+}
+```
+
+Product guide example:
+
+```json
+{
+  "slug": "example-product-guide",
+  "type": "guide",
+  "content_scope": "product:example-product",
+  "locale": "en",
+  "title": "How to Use Example Product",
+  "excerpt": "A short guide to using the example product.",
+  "content": "## Overview\n\nMarkdown content..."
+}
+```
+
+### `n2n_update_post`
+
+Update one locale of an existing post. Call `n2n_get_post` first.
+
+```json
+{
+  "id_or_slug": "example-product-guide",
+  "locale": "de",
+  "title": "So verwenden Sie Example Product",
+  "excerpt": "A localized summary for the selected locale.",
+  "content": "## Ueberblick\n\nLocalized Markdown content..."
+}
+```
+
+### `n2n_publish_post`
+
+Publish an existing draft.
+
+```json
+{
+  "id_or_slug": "example-product-guide"
+}
+```
+
+## Content format
+
+- Submit one locale per create or update call.
+- Use Markdown for `content`.
+- Use fenced code blocks for commands, JSON, YAML, and code examples.
+- Use Markdown image syntax for images.
+- Always include descriptive image alt text.
+- Reference public image URLs or existing site paths.
+- This MCP does not upload images in v1.
+
+Image example:
+
+```md
+![Product dashboard showing content status](/images/guides/content-status.png)
+```
+
+## Safety boundaries
+
+N2N Post2Site should not expose:
+
+- Delete operations.
+- Product configuration writes.
+- Pricing plan writes.
+- User administration.
+- Payment or subscription administration.
+- Database queries.
+- Log access.
+- Shell commands.
+- Deployment or server operations.
+
+Recommended backend behavior:
+
+- Sanitize backend errors before returning them to the AI client.
+- Use a site-scoped API key with the minimum permissions needed.
+- Create drafts by default.
+- Keep create/update and publish separate.
+- Set `published_at` on the backend, not from MCP input.
+
+## Laravel backend package direction
+
+A Laravel package can implement the HTTP side of this contract for multiple Laravel sites without copying controllers between projects. N2N Post2Site should stay a generic MCP client of that contract.
+
+## About N2NS Lab
+
+Built by N2NS Lab, short for Next-to-Native Systems Lab, Datafrog's open-source lab for AI-native developer tools.
+
+Learn more: https://n2ns.com
+
+Source repository: git@github.com:n2ns/n2n-post2site.git

package/dist/config.js

@@ -0,0 +1,14 @@
+export function loadConfig(env = process.env) {
+    const apiBaseUrl = normalizeBaseUrl(env.CONTENT_API_BASE_URL ?? '');
+    const apiKey = env.CONTENT_API_KEY;
+    if (!apiBaseUrl) {
+        throw new Error('CONTENT_API_BASE_URL is required. Point it at your protected content API base URL.');
+    }
+    if (!apiKey) {
+        throw new Error('CONTENT_API_KEY is required. Pass a site-scoped content API token as an environment variable.');
+    }
+    return { apiBaseUrl, apiKey };
+}
+function normalizeBaseUrl(value) {
+    return value.replace(/\/+$/, '');
+}

package/dist/content-client.js

@@ -0,0 +1,77 @@
+const POSTS_PATH = '/posts';
+const CAPABILITIES_PATH = '/capabilities';
+const PRODUCTS_PATH = '/products';
+export class ContentClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async getCapabilities() {
+        return this.request(CAPABILITIES_PATH, { method: 'GET' });
+    }
+    async listPosts(input) {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(input)) {
+            if (value === undefined)
+                continue;
+            params.set(key, String(value));
+        }
+        const suffix = params.toString() ? `?${params.toString()}` : '';
+        return this.request(`${POSTS_PATH}${suffix}`, { method: 'GET' });
+    }
+    async getPost(idOrSlug) {
+        return this.request(`${POSTS_PATH}/${encodeURIComponent(idOrSlug)}`, { method: 'GET' });
+    }
+    async getProductContext(input) {
+        return this.request(`${PRODUCTS_PATH}/${encodeURIComponent(input.content_scope)}`, { method: 'GET' });
+    }
+    async createPost(input) {
+        return this.request(POSTS_PATH, {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+    }
+    async updatePost(input) {
+        const { id_or_slug: idOrSlug, ...payload } = input;
+        return this.request(`${POSTS_PATH}/${encodeURIComponent(idOrSlug)}`, {
+            method: 'PATCH',
+            body: JSON.stringify(payload),
+        });
+    }
+    async publishPost(idOrSlug) {
+        return this.request(`${POSTS_PATH}/${encodeURIComponent(idOrSlug)}/publish`, {
+            method: 'POST',
+        });
+    }
+    async request(path, init) {
+        const response = await fetch(`${this.config.apiBaseUrl}${path}`, {
+            ...init,
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+                'X-API-KEY': this.config.apiKey,
+                Authorization: `Bearer ${this.config.apiKey}`,
+                ...(init.headers ?? {}),
+            },
+        });
+        const text = await response.text();
+        const body = parseJsonOrText(text);
+        if (!response.ok) {
+            throw new Error(`Content API request failed: ${response.status} ${response.statusText}: ${formatBody(body)}`);
+        }
+        return body;
+    }
+}
+function parseJsonOrText(text) {
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function formatBody(body) {
+    return typeof body === 'string' ? body : JSON.stringify(body, null, 2);
+}

package/dist/index.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { loadConfig } from './config.js';
+import { ContentClient } from './content-client.js';
+import { assertContentPostShape, capabilitiesSchema, createPostSchema, getPostSchema, listPostsSchema, productContextSchema, publishPostSchema, updatePostSchema, } from './schemas/blog-post.js';
+const server = new McpServer({
+    name: 'n2n-post2site',
+    version: '0.1.2',
+});
+const client = new ContentClient(loadConfig());
+server.tool('n2n_get_capabilities', 'Read the backend Content Publishing API Contract before creating or updating content. Use this to discover supported content types, locales, content_scope rules, and product guide scopes.', capabilitiesSchema.shape, async (input) => {
+    capabilitiesSchema.parse(input);
+    const result = await client.getCapabilities();
+    return textResult(result);
+});
+server.tool('n2n_list_posts', 'Search and list existing website articles or product guides before drafting new content. Use this to avoid duplicate topics and conflicting guidance. For product guides, filter by content_scope. Use content_scope="" for unscoped company blog posts when the backend supports it.', listPostsSchema.shape, async (input) => {
+    const parsed = listPostsSchema.parse(input);
+    const result = await client.listPosts(parsed);
+    return textResult(result);
+});
+server.tool('n2n_get_post', 'Read one existing article or guide by numeric ID or slug. Use this before updating a post, completing missing locales, or writing a follow-up article that depends on previous content.', getPostSchema.shape, async (input) => {
+    const parsed = getPostSchema.parse(input);
+    const result = await client.getPost(parsed.id_or_slug);
+    return textResult(result);
+});
+server.tool('n2n_get_product_context', 'Read the controlled product fact sheet before writing a product guide. The backend returns content_scope, canonical_url, docs_url, summary, key_points, and do_not_claim so the article does not invent product facts.', productContextSchema.shape, async (input) => {
+    const parsed = productContextSchema.parse(input);
+    assertContentPostShape({ type: 'guide', content_scope: parsed.content_scope });
+    const result = await client.getProductContext(parsed);
+    return textResult(result);
+});
+server.tool('n2n_create_post', 'Create an article draft or product guide draft with one locale per call. Before creating new content, search existing posts with n2n_list_posts to avoid duplicates. Before creating a product guide, also call n2n_get_product_context for the target content_scope and follow its canonical_url, docs_url, summary, key_points, and do_not_claim. content must be a Markdown document string; inline HTML is allowed when useful. title and excerpt must be plain text. The backend returns missing_locales when more language versions should be added. Use n2n_publish_post to publish.', createPostSchema.shape, async (input) => {
+    const parsed = createPostSchema.parse(input);
+    assertContentPostShape(parsed);
+    const result = await client.createPost(parsed);
+    return textResult(result);
+});
+server.tool('n2n_update_post', 'Update one locale of an existing article or guide by ID or slug. Always call n2n_get_post first so edits preserve existing content and metadata. content must be a Markdown document string; inline HTML is allowed when useful. title and excerpt must be plain text. Use repeated calls with different locale values to add missing language versions.', updatePostSchema.shape, async (input) => {
+    const parsed = updatePostSchema.parse(input);
+    assertContentPostShape(parsed);
+    const result = await client.updatePost(parsed);
+    return textResult(result);
+});
+server.tool('n2n_publish_post', 'Publish an existing article or guide by ID or slug. Publishing is intentionally separate from create/update to avoid accidental publication.', publishPostSchema.shape, async (input) => {
+    const parsed = publishPostSchema.parse(input);
+    const result = await client.publishPost(parsed.id_or_slug);
+    return textResult(result);
+});
+function textResult(value) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(value, null, 2),
+            },
+        ],
+    };
+}
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`n2n-post2site failed: ${message}`);
+    process.exit(1);
+});

package/dist/schemas/blog-post.js

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+export const contentTypeSchema = z.enum(['technical', 'announcement', 'changelog', 'guide']);
+export const statusSchema = z.enum(['draft', 'published']);
+export const localeSchema = z.enum(['en', 'zh_CN', 'es', 'de']);
+export const capabilitiesSchema = z.object({});
+export const listPostsSchema = z.object({
+    status: statusSchema.optional().describe('Filter by publication status.'),
+    type: contentTypeSchema.optional().describe('Filter by content type. Use guide for product or collection guide articles.'),
+    content_scope: z.string().optional().describe('Optional site-defined canonical publishing scope for guides, products, or collections. Use kind:key, for example product:example-product. Use an empty string to list unscoped company blog posts when the backend supports it.'),
+    q: z.string().optional().describe('Search query across title, content, and translations.'),
+    per_page: z.number().int().min(1).max(100).optional().describe('Page size. Defaults to the server value.'),
+});
+export const getPostSchema = z.object({
+    id_or_slug: z.string().min(1).describe('Numeric ID or slug of the article.'),
+});
+export const productContextSchema = z.object({
+    content_scope: z.string().min(1).describe('Product guide scope in kind:key format, for example product:evisa-helper. Read this before writing a product guide.'),
+});
+export const createPostSchema = z.object({
+    slug: z.string().min(1).describe('Globally unique URL slug.'),
+    type: contentTypeSchema.default('technical').describe('Use guide for product or collection guide articles.'),
+    content_scope: z.string().optional().describe('Required when type is guide. Use kind:key, for example product:example-product, project:example-project, or collection:example-collection.'),
+    locale: localeSchema.default('en').describe('Locale for this single-language submission. Submit one locale per tool call.'),
+    title: z.string().min(1).describe('Plain text title for the selected locale. Do not use Markdown here.'),
+    excerpt: z.string().optional().describe('Plain text summary for the selected locale. No Markdown headings, tables, or images.'),
+    content: z.string().min(1).describe('Markdown article body for the selected locale. Markdown image syntax is allowed. Inline HTML is allowed when useful.'),
+    thumbnail: z.string().optional().describe('Optional public image path or URL for the article thumbnail.'),
+});
+export const updatePostSchema = createPostSchema.partial().extend({
+    id_or_slug: z.string().min(1).describe('Numeric ID or slug of the article to update.'),
+});
+export const publishPostSchema = getPostSchema;
+export function assertContentPostShape(input) {
+    const type = input.type ?? 'technical';
+    const content_scope = input.content_scope;
+    if (type === 'guide' && !content_scope) {
+        throw new Error('content_scope is required when type is guide. Use a kind:key value such as product:example-product, project:example-project, or collection:example-collection.');
+    }
+    if (type !== 'guide' && content_scope) {
+        throw new Error('content_scope is only allowed when type is guide. Omit content_scope for unscoped company blog posts.');
+    }
+    if (content_scope && !/^[a-z][a-z0-9_-]*:[a-z0-9][a-z0-9_-]*$/.test(content_scope)) {
+        throw new Error('content_scope must use kind:key format, for example product:example-product.');
+    }
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "n2n-post2site",
+  "version": "0.1.2",
+  "description": "AI-assisted content publishing MCP server for blogs and product guides.",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/n2ns/n2n-post2site.git"
+  },
+  "type": "module",
+  "bin": {
+    "n2n-post2site": "dist/index.js"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc && chmod 755 dist/index.js",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "check": "npm run build && npm test"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "tsx": "^4.22.4",
+    "typescript": "^5.8.3",
+    "vitest": "^4.1.8"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    ".env.example"
+  ],
+  "license": "MIT"
+}