n2n-post2site 0.1.2 → 0.1.3

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 All notable changes to N2N Post2Site are documented in this file.
 
+## Unreleased
+
+### Added
+
+- None yet.
+
+## [0.1.3] - 2026-06-17
+
+### Added
+
+- Added `n2n_list_drafts` for listing unpublished drafts through the existing posts endpoint with `status=draft`.
+- Added `n2n_update_draft`, which reads the target post first and refuses to patch unless the backend reports `status: "draft"`.
+- Added `docs/ARCHITECTURE.md` to document runtime layers, module boundaries, and request flow.
+
+### Changed
+
+- Added `docs/ARCHITECTURE.md` to the README related docs list.
+- Bumped package version to `0.1.3`.
+
 ## [0.1.2] - 2026-06-15
 
 ### Added

package/README.md

@@ -1,4 +1,8 @@
-# N2N Post2Site
+<p align="center">
+  <img src="./assets/n2n-post2site-logo.png" width="128" alt="n2n-post2site logo">
+</p>
+
+# n2n-post2site
 
 AI-assisted content publishing MCP server for blogs and product guides.
 
@@ -9,37 +13,21 @@ AI-assisted content publishing MCP server for blogs and product guides.
 [![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.
+> **Draft with AI. Publish with intent.**
 
-## When to use it
+n2n-post2site is an open-source Model Context Protocol (MCP) server that lets an AI assistant draft, edit, review, and publish website content through a narrow Content Publishing API Contract. It is a local MCP bridge between your IDE assistant and your website content API — intentionally small, with no database access, shell access, deployment access, payment access, or user administration access.
 
-Use N2N Post2Site when you want an AI assistant to help with:
+## 💡 What is n2n-post2site?
 
-- Company blog posts.
-- Product guides.
-- Technical field notes.
-- Release notes and changelogs.
-- Localized article drafts.
-- Safe updates to existing website content.
+n2n-post2site gives AI coding assistants a structured path to draft and publish website content without exposing the database, file system, or deployment layer. Your backend implements the Content Publishing API Contract; the MCP server forwards AI tool calls to it.
 
-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.
+Use it for blog posts, product guides, technical notes, release notes, and localized article drafts. It is not a CMS — no admin panel, no storage backend, no image uploads (v1), no deployment workflow.
 
-## Publishing model
+## 📰 Publishing model
 
-N2N Post2Site works with two publishing spaces:
+n2n-post2site works with two publishing spaces:
 
 | Space | `content_scope` | Example |
 |---|---|---|
@@ -54,50 +42,17 @@ The assistant should follow this workflow:
 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.
+5. Resume unfinished work with `n2n_list_drafts`, `n2n_get_post`, and `n2n_update_draft`.
+6. Review the draft.
+7. Publish only through `n2n_publish_post`.
 
-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.
+## 🚀 Quick start
 
-Do not put API keys in prompts, article content, README examples, or screenshots.
+**Requirements**: Node.js 22+, an MCP-capable client, a site-scoped API key, and a backend that implements the [Content Publishing API Contract](./docs/BACKEND_API.md).
 
-## MCP client examples
+### 1. Configure your MCP client
 
-### Using the npm package
+Using the npm package:
 
 ```json
 {
@@ -106,15 +61,15 @@ Do not put API keys in prompts, article content, README examples, or screenshots
       "command": "npx",
       "args": ["-y", "n2n-post2site"],
       "env": {
-        "CONTENT_API_BASE_URL": "https://example.com/api/v1/mcp",
-        "CONTENT_API_KEY": "change-me"
+        "CONTENT_API_BASE_URL": "https://your-site.com/api/v1/mcp",
+        "CONTENT_API_KEY": "your-api-key"
       }
     }
   }
 }
 ```
 
-### Using a local checkout
+Using a local checkout:
 
 ```json
 {
@@ -123,185 +78,34 @@ Do not put API keys in prompts, article content, README examples, or screenshots
       "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"
+        "CONTENT_API_BASE_URL": "https://your-site.com/api/v1/mcp",
+        "CONTENT_API_KEY": "your-api-key"
       }
     }
   }
 }
 ```
 
-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:
+- `CONTENT_API_BASE_URL`: base URL of your protected content API. Keep path and field mapping in the backend adapter.
+- `CONTENT_API_KEY`: site-scoped API key. Do not put it in prompts, article content, or screenshots.
 
-- `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`.
+Bind one server instance to exactly one website.
 
-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.
+## 🔗 Backend API contract
 
-## MCP tools
+n2n-post2site connects to any backend that implements the Content Publishing API Contract. The contract defines the required endpoints, payload rules, and security requirements.
 
-### `n2n_get_capabilities`
+See **[Backend API Contract](./docs/BACKEND_API.md)** for the full specification.
 
-Read backend capabilities before creating or updating content.
-
-```json
-{}
-```
+## 🛠️ MCP tools
 
-### `n2n_list_posts`
+- **Discovery**: read backend capabilities, list existing posts, and load product context before drafting.
+- **Drafting**: create posts, update posts one locale at a time, and resume unpublished drafts.
+- **Publishing**: publish an approved draft through an explicit publish step.
 
-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"
-}
-```
+See [Tools reference](./docs/TOOLS_REFERENCE.md) for parameter schemas and call examples.
 
-## Content format
+## 📝 Content format
 
 - Submit one locale per create or update call.
 - Use Markdown for `content`.
@@ -317,9 +121,9 @@ Image example:
 ![Product dashboard showing content status](/images/guides/content-status.png)
 ```
 
-## Safety boundaries
+## 🔐 Security and governance notes
 
-N2N Post2Site should not expose:
+n2n-post2site should not expose:
 
 - Delete operations.
 - Product configuration writes.
@@ -339,14 +143,20 @@ Recommended backend behavior:
 - Keep create/update and publish separate.
 - Set `published_at` on the backend, not from MCP input.
 
-## Laravel backend package direction
+## 📖 Related docs
 
-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.
+- **[Backend API Contract](./docs/BACKEND_API.md)**: Endpoints, payload rules, and security requirements for backend implementors.
+- **[Architecture](./docs/ARCHITECTURE.md)**: Runtime layers, module boundaries, and request flow in the MCP server.
+- **[Tools reference](./docs/TOOLS_REFERENCE.md)**: MCP tool parameter schemas and call examples.
+- **[Roadmap](./ROADMAP.md)**: Planned features and what's coming next.
+- **[Changelog](./CHANGELOG.md)**: Version history and release notes.
+- **[Contributing](./CONTRIBUTING.md)**: How to report issues and contribute.
+- **[Security](./SECURITY.md)**: How to report vulnerabilities.
 
-## About N2NS Lab
+## 📄 License
 
-Built by N2NS Lab, short for Next-to-Native Systems Lab, Datafrog's open-source lab for AI-native developer tools.
+This project is licensed under the [MIT License](./LICENSE).
 
-Learn more: https://n2ns.com
+---
 
-Source repository: git@github.com:n2ns/n2n-post2site.git
+Built by [N2NS Lab](https://n2ns.com), the open-source lab of [datafrog.io](https://datafrog.io) for practical AI developer tools.

package/dist/content-client.js

@@ -1,10 +1,13 @@
+import { FetchHttpTransport } from './transport/http.js';
 const POSTS_PATH = '/posts';
 const CAPABILITIES_PATH = '/capabilities';
 const PRODUCTS_PATH = '/products';
 export class ContentClient {
     config;
-    constructor(config) {
+    transport;
+    constructor(config, transport = new FetchHttpTransport(config)) {
         this.config = config;
+        this.transport = transport;
     }
     async getCapabilities() {
         return this.request(CAPABILITIES_PATH, { method: 'GET' });
@@ -12,13 +15,17 @@ export class ContentClient {
     async listPosts(input) {
         const params = new URLSearchParams();
         for (const [key, value] of Object.entries(input)) {
-            if (value === undefined)
+            if (value === undefined) {
                 continue;
+            }
             params.set(key, String(value));
         }
         const suffix = params.toString() ? `?${params.toString()}` : '';
         return this.request(`${POSTS_PATH}${suffix}`, { method: 'GET' });
     }
+    async listDrafts(input) {
+        return this.listPosts({ ...input, status: 'draft' });
+    }
     async getPost(idOrSlug) {
         return this.request(`${POSTS_PATH}/${encodeURIComponent(idOrSlug)}`, { method: 'GET' });
     }
@@ -38,13 +45,18 @@ export class ContentClient {
             body: JSON.stringify(payload),
         });
     }
+    async updateDraft(input) {
+        const existingPost = await this.getPost(input.id_or_slug);
+        assertDraftStatus(existingPost);
+        return this.updatePost(input);
+    }
     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}`, {
+        const response = await this.transport.request(path, {
             ...init,
             headers: {
                 Accept: 'application/json',
@@ -54,24 +66,31 @@ export class ContentClient {
                 ...(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)}`);
+            throw new Error(`Content API request failed: ${response.status} ${response.statusText}: ${formatBody(response.body)}`);
         }
-        return body;
+        return response.body;
     }
 }
-function parseJsonOrText(text) {
-    if (!text)
-        return null;
-    try {
-        return JSON.parse(text);
+function formatBody(body) {
+    return typeof body === 'string' ? body : JSON.stringify(body, null, 2);
+}
+function assertDraftStatus(body) {
+    const status = extractPostStatus(body);
+    if (status === 'draft') {
+        return;
     }
-    catch {
-        return text;
+    if (status) {
+        throw new Error(`n2n_update_draft requires a draft post. Current status: ${status}.`);
     }
+    throw new Error('n2n_update_draft could not verify draft status. The backend GET /posts/{id_or_slug} response must include a status field.');
 }
-function formatBody(body) {
-    return typeof body === 'string' ? body : JSON.stringify(body, null, 2);
+function extractPostStatus(body) {
+    const record = asRecord(body);
+    const post = asRecord(record?.blog_post) ?? asRecord(record?.data) ?? record;
+    const status = post?.status;
+    return typeof status === 'string' ? status : undefined;
+}
+function asRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
 }

package/dist/index.js

@@ -1,62 +1,8 @@
 #!/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),
-            },
-        ],
-    };
-}
+import { createServer } from './server.js';
+const server = createServer(loadConfig());
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/result.js

@@ -0,0 +1,10 @@
+export function createTextResult(value) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(value, null, 2),
+            },
+        ],
+    };
+}

package/dist/schemas/blog-post.js

@@ -10,6 +10,7 @@ export const listPostsSchema = z.object({
     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 listDraftsSchema = listPostsSchema.omit({ status: true });
 export const getPostSchema = z.object({
     id_or_slug: z.string().min(1).describe('Numeric ID or slug of the article.'),
 });
@@ -29,6 +30,7 @@ export const createPostSchema = z.object({
 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 updateDraftSchema = updatePostSchema;
 export const publishPostSchema = getPostSchema;
 export function assertContentPostShape(input) {
     const type = input.type ?? 'technical';

package/dist/server.js

@@ -0,0 +1,28 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { ContentClient } from './content-client.js';
+import { registerCreatePostTool } from './tools/create-post.js';
+import { registerGetCapabilitiesTool } from './tools/get-capabilities.js';
+import { registerGetPostTool } from './tools/get-post.js';
+import { registerGetProductContextTool } from './tools/get-product-context.js';
+import { registerListDraftsTool } from './tools/list-drafts.js';
+import { registerListPostsTool } from './tools/list-posts.js';
+import { registerPublishPostTool } from './tools/publish-post.js';
+import { registerUpdateDraftTool } from './tools/update-draft.js';
+import { registerUpdatePostTool } from './tools/update-post.js';
+export function createServer(config) {
+    const client = new ContentClient(config);
+    const server = new McpServer({
+        name: 'n2n-post2site',
+        version: '0.1.2',
+    });
+    registerGetCapabilitiesTool(server, client);
+    registerListPostsTool(server, client);
+    registerListDraftsTool(server, client);
+    registerGetPostTool(server, client);
+    registerGetProductContextTool(server, client);
+    registerCreatePostTool(server, client);
+    registerUpdatePostTool(server, client);
+    registerUpdateDraftTool(server, client);
+    registerPublishPostTool(server, client);
+    return server;
+}

package/dist/tools/create-post.js

@@ -0,0 +1,10 @@
+import { createTextResult } from '../result.js';
+import { assertContentPostShape, createPostSchema } from '../schemas/blog-post.js';
+export function registerCreatePostTool(server, client) {
+    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 createTextResult(result);
+    });
+}

package/dist/tools/get-capabilities.js

@@ -0,0 +1,9 @@
+import { createTextResult } from '../result.js';
+import { capabilitiesSchema } from '../schemas/blog-post.js';
+export function registerGetCapabilitiesTool(server, client) {
+    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 createTextResult(result);
+    });
+}

package/dist/tools/get-post.js

@@ -0,0 +1,9 @@
+import { createTextResult } from '../result.js';
+import { getPostSchema } from '../schemas/blog-post.js';
+export function registerGetPostTool(server, client) {
+    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 createTextResult(result);
+    });
+}

package/dist/tools/get-product-context.js

@@ -0,0 +1,10 @@
+import { createTextResult } from '../result.js';
+import { assertContentPostShape, productContextSchema } from '../schemas/blog-post.js';
+export function registerGetProductContextTool(server, client) {
+    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 createTextResult(result);
+    });
+}

package/dist/tools/list-drafts.js

@@ -0,0 +1,9 @@
+import { createTextResult } from '../result.js';
+import { listDraftsSchema } from '../schemas/blog-post.js';
+export function registerListDraftsTool(server, client) {
+    server.tool('n2n_list_drafts', 'List unpublished draft articles or product guides. Use this before resuming previous AI-written drafts. This tool always filters status=draft; use type, content_scope, q, and per_page to narrow the results.', listDraftsSchema.shape, async (input) => {
+        const parsed = listDraftsSchema.parse(input);
+        const result = await client.listDrafts(parsed);
+        return createTextResult(result);
+    });
+}

package/dist/tools/list-posts.js

@@ -0,0 +1,9 @@
+import { createTextResult } from '../result.js';
+import { listPostsSchema } from '../schemas/blog-post.js';
+export function registerListPostsTool(server, client) {
+    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 createTextResult(result);
+    });
+}

package/dist/tools/publish-post.js

@@ -0,0 +1,9 @@
+import { createTextResult } from '../result.js';
+import { publishPostSchema } from '../schemas/blog-post.js';
+export function registerPublishPostTool(server, client) {
+    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 createTextResult(result);
+    });
+}

package/dist/tools/update-draft.js

@@ -0,0 +1,10 @@
+import { createTextResult } from '../result.js';
+import { assertContentPostShape, updateDraftSchema } from '../schemas/blog-post.js';
+export function registerUpdateDraftTool(server, client) {
+    server.tool('n2n_update_draft', 'Update one locale of an unpublished draft by ID or slug. The client reads the post first and refuses to patch unless the backend reports status=draft. Use n2n_list_drafts and n2n_get_post before calling this tool.', updateDraftSchema.shape, async (input) => {
+        const parsed = updateDraftSchema.parse(input);
+        assertContentPostShape(parsed);
+        const result = await client.updateDraft(parsed);
+        return createTextResult(result);
+    });
+}

package/dist/tools/update-post.js

@@ -0,0 +1,10 @@
+import { createTextResult } from '../result.js';
+import { assertContentPostShape, updatePostSchema } from '../schemas/blog-post.js';
+export function registerUpdatePostTool(server, client) {
+    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 createTextResult(result);
+    });
+}

package/dist/transport/http.js

@@ -0,0 +1,28 @@
+export class FetchHttpTransport {
+    baseUrl;
+    constructor(config) {
+        this.baseUrl = config.apiBaseUrl;
+    }
+    async request(path, init) {
+        const response = await fetch(`${this.baseUrl}${path}`, init);
+        const text = await response.text();
+        const body = parseJsonOrText(text);
+        return {
+            status: response.status,
+            statusText: response.statusText,
+            ok: response.ok,
+            body,
+        };
+    }
+}
+function parseJsonOrText(text) {
+    if (!text) {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}

package/docs/ARCHITECTURE.md

@@ -0,0 +1,127 @@
+# N2N Post2Site 架构说明（v0.1.2）
+
+本文档说明 `n2n-post2site` 当前架构，目标是约束边界、保留接口兼容，并让后续改动有稳定接入点。
+
+## 1. 系统定位
+
+`n2n-post2site` 是 MCP server，作用是：
+
+- 解析环境变量并创建 MCP Server 实例。
+- 向 MCP 客户端暴露 9 个内容发布工具。
+- 将工具参数转为对后端内容 API 的 HTTP 调用。
+- 将后端返回值统一封装为 MCP 可展示文本。
+
+它本身不承载持久化、权限管理、审核策略或内容排序决策；这些都应由后端 API 提供方实现。
+
+## 2. 分层结构
+
+### 2.1 运行入口层（`src/index.ts`）
+
+- 使用 `createServer(loadConfig())` 创建 MCP 实例。
+- 使用 `StdioServerTransport` 与 MCP 客户端通信。
+- 仅负责进程生命周期与失败输出。
+
+### 2.2 配置层（`src/config.ts`）
+
+- 读取环境变量：
+  - `CONTENT_API_BASE_URL`
+  - `CONTENT_API_KEY`
+- 校验缺失字段并报错。
+- 统一清理 `CONTENT_API_BASE_URL` 末尾斜杠。
+
+### 2.3 组装层（`src/server.ts`）
+
+- 只做“构建与注册”职责：
+  1. 构造 `ContentClient`
+  2. 新建 `McpServer`
+  3. 注册 9 个工具
+
+当前注册顺序：
+
+- `n2n_get_capabilities`
+- `n2n_list_posts`
+- `n2n_list_drafts`
+- `n2n_get_post`
+- `n2n_get_product_context`
+- `n2n_create_post`
+- `n2n_update_post`
+- `n2n_update_draft`
+- `n2n_publish_post`
+
+### 2.4 工具层（`src/tools/*.ts`）
+
+每个文件对应一个 MCP tool：
+
+- 参数校验（Zod schema + 业务约束断言）
+- 调用 `ContentClient` 对应方法
+- 返回统一 `text` 结果
+
+工具层职责不包含底层 HTTP、请求头、JSON 解析或路由拼接。
+
+### 2.5 传输与客户端层
+
+- `src/transport/http.ts`
+  - `HttpTransport` 接口
+  - 默认 `FetchHttpTransport` 封装 `fetch`
+  - 负责响应解析（JSON / text）、状态透传
+
+- `src/content-client.ts`
+  - 统一拼装路径与 HTTP 方法
+  - 注入鉴权头（`X-API-KEY` / `Authorization`）
+  - 统一处理非 2xx 报错为异常
+  - 聚合列表参数与路由参数
+  - 实现 `updateDraft` 的业务校验流程：
+    1. 先调用 `GET /posts/{id_or_slug}`
+    2. 校验 `status === 'draft'`
+    3. 才允许 `PATCH /posts/{id_or_slug}`
+
+### 2.6 模型与约束层（`src/schemas/blog-post.ts`）
+
+- Zod schema 定义所有工具输入约束。
+- `assertContentPostShape` 强化 `type/content_scope` 规则：
+  - `type=guide` 必须带 `content_scope`
+  - 非 guide 不允许带 `content_scope`
+  - `content_scope` 格式必须是 `kind:key`
+
+### 2.7 输出层（`src/result.ts`）
+
+- 用 `createTextResult` 将任意后端返回内容转为 MCP `content: [{type:'text', text:...}]`。
+- 维持了所有工具一致的返回格式。
+
+## 3. 请求流
+
+典型调用流（`n2n_create_post`）：
+
+1. MCP 工具接收参数
+2. Zod schema 校验 + 业务断言
+3. 调用 `ContentClient.createPost`
+4. `ContentClient` 构造请求并通过 `HttpTransport.request` 发起 HTTP
+5. 解析响应体并返回
+6. 工具层用 `createTextResult` 包装并返回给 MCP
+
+## 4. 关键不变式
+
+- 工具契约不变（9 个工具 + 名称 + 入参语义）
+- 后端接口契约不变（见 `docs/BACKEND_API.md`）
+- CLI/部署接口不变（`bin` 指向 `dist/index.js`）
+- 错误行为保持“尽早失败”：缺少配置或非法参数立即报错
+
+## 5. 测试边界
+
+- `tests/server.test.ts`：保证 9 个工具完整注册。
+- `tests/transport.test.ts`：验证 `FetchHttpTransport` 和 `ContentClient` 的请求层行为。
+
+## 6. 当前架构限制与改造方向
+
+当前设计有清晰分层，但仍是“轻量单体” MCP server：
+
+- 无运行时重试、幂等保护、限流和退避策略
+- 无完整错误分类体系（目前统一抛错）
+- 工具能力说明仍以静态文档描述为主
+
+后续可扩展点：
+
+- 新增 `errors.ts` 统一 API 错误模型
+- 在客户端层引入策略性重试/幂等
+- 引入服务层（如 `PostService`）汇聚更复杂业务流
+- 添加端到端契约测试覆盖错误返回形态

package/docs/BACKEND_API.md

@@ -0,0 +1,111 @@
+# Backend API Contract
+
+This document defines the HTTP contract that a backend must implement to work with N2N Post2Site. The MCP server connects to this contract through `CONTENT_API_BASE_URL` and `CONTENT_API_KEY`.
+
+## Required endpoints
+
+All endpoints are 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.
+
+The MCP server calls this endpoint before every create or update operation.
+
+## `GET /products/{content_scope}`
+
+Returns controlled product context before drafting product guides.
+
+Expected response fields:
+
+| Field | Description |
+| --- | --- |
+| `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. |
+
+## `GET /posts`
+
+Returns a list of existing posts. Supports filtering by `status`, `type`, `content_scope`, and a search query `q`.
+
+For automated internal linking and search, each post in the list should include:
+
+| Field | Description |
+| --- | --- |
+| `id` | Unique identifier. |
+| `title` | Post title. |
+| `slug` | Unique URL slug. |
+| `link` | Required for AI auto-linking. Absolute public URL of the published post on the live website, so AI clients do not guess paths. |
+
+## `GET /posts/{id_or_slug}`
+
+Returns a single post by ID or slug. The MCP server calls this before updating a post or completing missing locales.
+
+## `POST /posts` and `PATCH /posts/{id_or_slug}`
+
+Create and update calls use one locale per request.
+
+### Payload
+
+```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..."
+}
+```
+
+### Field 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 and update payloads must not accept `status`, `published_at`, `user_id`, or `author`.
+- Publishing state changes only through `POST /posts/{id_or_slug}/publish`.
+
+### Response conventions
+
+Backends may return `missing_locales` and `next_actions` after create, update, or publish. The MCP server will add missing language versions with additional update calls instead of asking the backend to auto-translate.
+
+## `POST /posts/{id_or_slug}/publish`
+
+Publishes an existing draft. Publishing state is managed exclusively through this endpoint, not through create or update payloads.
+
+## Draft-specific MCP tools
+
+`n2n_list_drafts` and `n2n_update_draft` do not require extra backend endpoints:
+
+- `n2n_list_drafts` calls `GET /posts` with `status=draft`.
+- `n2n_update_draft` calls `GET /posts/{id_or_slug}` first and refuses to continue unless the returned post has `status: "draft"`, then calls `PATCH /posts/{id_or_slug}`.
+
+## Security requirements
+
+- Use a site-scoped API key with the minimum permissions needed.
+- Sanitize backend errors before returning them to the MCP client.
+- Do not expose `user_id`, `author`, `published_at`, or other server-managed fields in create or update payloads.
+- Keep path mapping and field mapping in the backend adapter, not in MCP client configuration.

package/docs/REFACTOR_PLAN.md

@@ -0,0 +1,152 @@
+# N2N Post2Site 重构过程文档（v0.1.x 结构化解耦改造）
+
+> 目标：保持对外行为不变，先把模块拆分和职责边界补齐，为后续特性（如动态能力适配）做底座，降低耦合、提高可测试性与可维护性。
+
+## 1. 背景与动机
+
+当前实现中，`src/index.ts` 承担了以下过多职责：
+
+- MCP 工具注册
+- 参数校验与业务流编排
+- HTTP 客户端调用
+- 响应封装
+
+`src/content-client.ts` 中也同时承担了请求构建、鉴权、错误处理与状态校验。现有规模虽小，但未来增加能力动态化、重试、错误分类时会迅速耦合。
+
+本次改造目标是把耦合点拆开，不新增或变更外部 API 语义。
+
+## 2. 改造原则（硬约束）
+
+1. 不改变 MCP 工具的调用输入/输出行为。
+2. 不改变后端 Content API 的调用契约。
+3. 不改变命令行入口、环境变量和发布产物协议。
+4. 每个新模块应单一职责，文件改动最小且可回滚。
+5. 保留现有测试覆盖语义；先保证现有测试通过（`npm run check`）。
+
+## 3. 现状结构（重构前）
+
+- `src/index.ts`
+  - 启动 MCP 服务器
+  - 注册全部 9 个工具
+  - 工具内联处理 request/parse/result 输出
+- `src/content-client.ts`
+  - 直接构建并发送 `fetch`
+  - 鉴权头、错误处理、JSON 解析集中在同一类
+  - 状态校验（`updateDraft`）也在此处理
+- `src/schemas/blog-post.ts`
+  - 参数 schema 与运行时断言集中定义
+- `src/tools/`
+  - 每个 MCP 工具已拆到独立文件：`get-capabilities.ts`, `list-posts.ts`, `list-drafts.ts`, `get-post.ts`, `get-product-context.ts`, `create-post.ts`, `update-post.ts`, `update-draft.ts`, `publish-post.ts`
+
+## 4. 目标结构（重构后）
+
+目标是引入以下边界：
+
+- `src/server.ts`：仅负责 MCP Server 的实例化与工具注册（`index.ts` 作为入口）。
+- `src/tools/*Tool.ts`：每个 MCP 工具单文件（`get-capabilities.ts`, `list-posts.ts`, `list-drafts.ts`, `get-post.ts`, `get-product-context.ts`, `create-post.ts`, `update-post.ts`, `update-draft.ts`, `publish-post.ts`）。
+- `src/services/`
+  - `posts.ts`（可选）：封装 `updateDraft` 这类业务流（“读当前状态→校验→更新”）。
+  - 后续扩展点：发布、列表拼装、策略判断。
+- `src/transport/http.ts`
+  - `HttpTransport` 抽象与默认实现（`fetch` 封装）。
+  - 统一注入 `X-API-KEY`、`Authorization`、`Content-Type`。
+- `src/result.ts`
+  - 统一 MCP 文本结果格式。
+- `src/errors.ts`（可选）
+  - 自定义 API 错误对象（携带 endpoint、method、status、body）。
+- `src/types/`
+  - 放置会被服务层复用的公共类型（可选）。
+
+> 说明：`src/tools` 目录已存在，可直接使用，先按最小重构只做当前 9 个工具文件即可。
+
+## 5. 具体实施步骤
+
+### 阶段 1：执行层切分（最低风险）
+
+1. 新建 `src/result.ts`，抽离 `textResult()`。
+2. 新建 `src/transport/http.ts` 与 `HttpTransport` 接口。
+3. 重构 `ContentClient` 使用 transport 注入，去掉直接 `fetch` 依赖。
+4. 拆出 `src/server.ts`，让 `index.ts` 只做启动与异常出口。
+
+验收标准：
+
+- 行为不变（工具响应 JSON 字符串包装不变）。
+- `npm run check` 通过。
+
+### 阶段 2：工具拆文件（中等改动）
+
+1. 为每个 MCP tool 在 `src/tools/` 下新建处理模块。
+2. 每个模块只做：参数校验 + 对应 service/client 调用 + 返回统一 result。
+3. 将重复文案字符串逐步提取到常量（非强制）。
+
+验收标准：
+
+- `n2n_get_capabilities` 到 `n2n_publish_post` 全部可从新模块注册。
+- 与现有功能的可见行为一致。
+
+### 阶段 3：服务层与业务流集中化（可选但推荐）
+
+1. 将 `updateDraft` 中的“先拉取状态再 PATCH”的状态策略移动到 `posts.ts` 服务。
+2. 为未来新增业务动作预留 `PostService`。
+
+验收标准：
+
+- `updateDraft` 流程不变（仍拒绝非 draft）
+- `tests/client.test.ts` 中的行为断言可保持通过。
+
+### 阶段 4：文档与追踪更新
+
+1. 在本文件补充阶段完成记录。
+2. 可选地更新 `ROADMAP.md`，若该改造需要对外公开发布说明。
+3. 更新 `CHANGELOG.md`（若版本号/可见改动需要记录）。
+4. 如有新增文件夹，更新仓库文档索引（README 中可选）。
+
+> 当前执行状态：阶段 1~2 已完成；阶段 3 作为可选项保留；阶段 4 文档补充已完成（结构变更说明已更新，本次未更新 `ROADMAP.md`/`CHANGELOG.md`）。
+
+验收标准：
+
+- 代码和文档结构一致。
+- 未引入新外部行为依赖。
+
+## 6. 回滚策略
+
+- 所有改造分批提交（每个阶段单独 commit），遇到风险可回退最近提交。
+- 每次提交前保留 `main` 分支上的行为对照：通过 `npm run check` 作为门槛。
+- 不在功能层更改任何 schema/接口时，回滚风险低。
+
+## 7. 风险与对策
+
+1. **工具描述文字重复**
+   - 风险：文本变更导致行为认知差异
+   - 对策：保持文本不变；仅抽象常量。
+2. **测试脆弱性上升**
+   - 风险：拆分后导入路径变化导致 mock 失败
+   - 对策：保留现有 public 行为与导入边界，测试逐项执行通过。
+3. **过度重构（scope creep）**
+   - 风险：把未要求的能力（动态能力发现）一起引入
+   - 对策：本次只做解耦，不新增 schema 或协议。
+
+## 8. 交付定义（Acceptance）
+
+- `npm run check` 通过。
+- 工具行为回归对照未变：
+  - 发布流程
+  - 草稿状态检查
+  - 产品上下文读取
+- 不引入新的运行时依赖。
+- 不修改后端契约字段。
+
+## 9. 里程碑时间建议（可选）
+
+- 第一天：阶段 1~2（核心结构搭建）
+- 第一天：阶段 3~4（文档与清理）
+- 第二天：`npm run check` 与 smoke 验证（手工 1 次端到端）
+
+## 10. 变更边界声明
+
+本次方案不覆盖以下内容：
+
+- 动态能力驱动 schema（这是 `ROADMAP` 中 v0.2 规划项）。
+- 发布 API 新增功能。
+- 新增工具。
+- 后端能力模型扩展。

package/docs/TOOLS_REFERENCE.md

@@ -0,0 +1,142 @@
+# n2n-post2site tools reference
+
+This document describes the MCP tools provided by n2n-post2site. All tools connect to the backend at `CONTENT_API_BASE_URL` and authenticate with `CONTENT_API_KEY`.
+
+See [Backend API Contract](./BACKEND_API.md) for the endpoint specification the backend must implement.
+
+## `n2n_get_capabilities`
+
+Read backend capabilities before creating or updating content.
+
+```json
+{}
+```
+
+The backend returns supported content types, statuses, locales, input fields, `content_scope` rules, and safety boundaries. The MCP server calls this endpoint before every create or update operation.
+
+## `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 a filter only. Do not send `status` in create or update calls.
+
+## `n2n_list_drafts`
+
+List unpublished drafts. This is a draft-only convenience tool over `GET /posts?status=draft`.
+
+```json
+{
+  "type": "guide",
+  "content_scope": "product:example-product",
+  "q": "setup guide",
+  "per_page": 20
+}
+```
+
+## `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"
+}
+```
+
+The backend returns: `content_scope`, `canonical_url`, `docs_url`, `summary`, `key_points`, and `do_not_claim`.
+
+## `n2n_create_post`
+
+Create a draft. Publishing is a separate step.
+
+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_update_draft`
+
+Update one locale of an unpublished draft. The client reads the post first and refuses to patch unless the backend reports `status: "draft"`.
+
+```json
+{
+  "id_or_slug": "example-product-guide",
+  "locale": "en",
+  "title": "How to Use Example Product",
+  "excerpt": "A refined summary for the draft.",
+  "content": "## Overview\n\nUpdated draft Markdown content..."
+}
+```
+
+## `n2n_publish_post`
+
+Publish an existing draft.
+
+```json
+{
+  "id_or_slug": "example-product-guide"
+}
+```
+
+Publishing state is managed exclusively through this tool, not through create or update payloads.
+
+## Client method mapping
+
+- `ContentClient.listDrafts(input)` calls `GET /posts` with `status=draft` plus the provided list filters.
+- `ContentClient.updateDraft(input)` calls `GET /posts/{id_or_slug}` first, checks `status === "draft"`, then calls `PATCH /posts/{id_or_slug}`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n2n-post2site",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "AI-assisted content publishing MCP server for blogs and product guides.",
   "repository": {
     "type": "git",
@@ -31,9 +31,16 @@
   },
   "files": [
     "dist",
+    "assets",
+    "docs",
     "README.md",
     "CHANGELOG.md",
     ".env.example"
   ],
+  "author": "N2NS Lab",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/n2ns"
+  },
   "license": "MIT"
 }