@blogautomation/mcp-server 0.0.0-stage → 1.0.1

package/README.md

@@ -1,3 +1,74 @@
-# Temporary Holding Version
+# Blog Automation MCP server
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[Model Context Protocol](https://modelcontextprotocol.io) server for **Blog Automation** (https://blog-automation.com): plan ideas, write
+articles with AI, publish or schedule them on WordPress and check the token balance – from Claude, ChatGPT, Cursor or any MCP client.
+It is a thin wrapper around the Customer API `https://app.blog-automation.com/api/v1/ext` (app repo `blogposter-app`, `server/routes/ext.js`,
+`docs/API.md`). Node 22, `@modelcontextprotocol/sdk` 1.32, zod 4. Package `@blogautomation/mcp-server`, command `blog-automation-mcp`.
+
+## Tools
+
+| Tool | API call | Notes |
+|---|---|---|
+| `list_ideas` | `GET /ideas` | status, siteId, limit, cursor – read only |
+| `create_idea` | `POST /ideas` | title (+ keyword, notes, audience, priority 1–3, language, siteId); `Idempotency-Key` |
+| `write_article` | `POST /articles/generate` `{ …, async: true }` → 202 `{ job }`, then `GET /jobs/{id}` every 3 s | **uses tokens**; waits ≈ 50 s, then returns `jobId` (→ `job_status`); answer without HTML; `Idempotency-Key` |
+| `job_status` | `GET /jobs/{id}` | running / done (article) / failed (error) |
+| `list_articles` | `GET /articles` | status list, siteId, q, limit, cursor (no HTML) |
+| `get_article` | `GET /articles/{id}` | with HTML and SEO fields |
+| `article_status` | `GET /articles/{id}/status` | status, schedule, WordPress link, last error, job |
+| `publish_article` | `POST /articles/{id}/publish` or, with `at`, `POST /articles/{id}/schedule` | `at` = ISO time or `"next"` (next free slot = "add to calendar") |
+| `token_balance` | `GET /tokens` | balance, lots, prices |
+| `list_sites` | `GET /sites` | WordPress sites (ids for `siteId`) |
+| `list_templates` | `GET /templates` | built-in `b:…` and own templates |
+
+Errors come back as readable tool results with `isError: true`: 401 (key invalid/revoked), 402 (not enough tokens: needed / balance),
+403 `insufficient_scope` (which scope is missing) / `plan_required` (which plans have the API), 404, 429 (seconds from `Retry-After`).
+
+## API key
+
+Blog Automation → **Entwickler / API** → "API-Key erstellen" (plans Starter and Pro). Scopes:
+`articles:read`, `articles:write`, `ai:generate` (write_article), `articles:publish` (publish_article), `ideas:read`, `ideas:write`,
+`templates:read`, `sites:read`, `account:read` (token_balance). Leave out what the assistant should not do – e.g. without
+`articles:publish` it can write drafts but never publish.
+
+## Use it
+
+**stdio** (local; the key comes from `BA_API_KEY`):
+
+```bash
+npx -y @blogautomation/mcp-server          # once published; from this repo: node mcp/src/cli.js
+```
+
+Claude Desktop (`claude_desktop_config.json`) / Cursor (`~/.cursor/mcp.json`) – same block:
+
+```json
+{ "mcpServers": { "blog-automation": { "command": "npx", "args": ["-y", "@blogautomation/mcp-server"], "env": { "BA_API_KEY": "ba_live_…" } } } }
+```
+
+Claude Code: `claude mcp add blog-automation --env BA_API_KEY=ba_live_… -- npx -y @blogautomation/mcp-server`
+
+**Streamable HTTP** (remote clients – ChatGPT connectors / developer mode, Claude "custom connector", Cursor via URL):
+
+```bash
+blog-automation-mcp --http --port 8787 --host 127.0.0.1 --origin https://chatgpt.com,https://claude.ai
+```
+
+- Endpoint `POST /mcp` (stateless, JSON responses), health check `GET /healthz`. GET/DELETE on `/mcp` → 405 (no sessions).
+- Every request must send `Authorization: Bearer ba_live_…`; the key is used only for that request's API calls – not stored, not logged.
+  Missing or malformed → 401 with `WWW-Authenticate: Bearer`.
+- Requests with an `Origin` header are only accepted from `--origin` / `BA_MCP_ORIGINS` (DNS-rebinding protection); without the option
+  browser requests are refused, server-to-server calls (no Origin) work.
+- Binds 127.0.0.1 by default; put it behind the reverse proxy (TLS) for public use, e.g. `https://mcp.blog-automation.com/mcp`.
+- Clients that only do OAuth (no custom header) cannot use it yet – see SUBMISSION.md.
+
+`BA_API_BASE` overrides the API (e.g. `https://pre.blog-automation.com/api/v1/ext`).
+
+## Develop
+
+```bash
+cd mcp && npm install && npm test     # node:test – 7 tests, fake API (no network, no key)
+```
+
+Tests: tools/list (names, annotations, schemas), request shape of every tool, Idempotency-Key, async job polling (done / still running /
+failed), publish vs. schedule, error mapping (401/402/403/404/429), HTTP transport (healthz, 401, Origin 403, 405, tools/list + call with
+the request's key).

package/package.json

@@ -1,6 +1,42 @@
 {
   "name": "@blogautomation/mcp-server",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "description": "MCP server for Blog Automation \u2013 plan ideas, write articles with AI, publish to WordPress, Shopify and 30+ platforms and check tokens from Claude, ChatGPT, Cursor and other MCP clients.",
+  "type": "module",
+  "license": "MIT",
+  "mcpName": "io.github.shsoftwaresolutioncom/blog-automation-mcp",
+  "bin": {
+    "blog-automation-mcp": "src/cli.js"
+  },
+  "main": "src/server.js",
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "start": "node src/cli.js",
+    "start:http": "node src/cli.js --http",
+    "test": "node --test \"test/*.test.js\""
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.32.2",
+    "zod": "^4.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shsoftwaresolutioncom/blog-automation-mcp.git"
+  },
+  "homepage": "https://blog-automation.com/en/",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "blog",
+    "ai",
+    "wordpress",
+    "seo",
+    "blog-automation"
+  ]
+}

package/src/api.js

@@ -0,0 +1,48 @@
+// Thin client for the Blog Automation Customer API (/api/v1/ext). The key is passed in per client – never stored or logged.
+import { randomUUID } from 'node:crypto';
+
+export const DEFAULT_BASE = 'https://app.blog-automation.com/api/v1/ext';
+export const KEY_RE = /^ba_live_[A-Za-z0-9_-]{30,64}$/;
+const UA = 'BlogAutomation-MCP/1.0 (+https://blog-automation.com)';
+
+export class ApiError extends Error {
+  constructor(status, body, headers) {
+    super(body?.message || body?.error || `HTTP ${status}`);
+    this.status = status; this.body = body || {}; this.retryAfter = headers?.get?.('retry-after') || null;
+  }
+}
+
+/** Readable text for an API error (shown to the model / person as an isError tool result). */
+export function explain(e) {
+  if (!(e instanceof ApiError)) return `Blog Automation could not be reached: ${e?.message || e}`;
+  const b = e.body;
+  if (e.status === 401) return 'The Blog Automation API key is missing, invalid, expired or revoked. Create a key in Blog Automation → Entwickler / API.';
+  if (e.status === 402) return `Not enough tokens for this AI action (needed ${b.needed ?? '?'}, balance ${b.balance ?? '?'}). Buy a refill or upgrade in Blog Automation → Tokens.`;
+  if (e.status === 403 && b.error === 'plan_required') return `The API is not included in this plan${b.plans ? ` (available in: ${b.plans.join(', ')})` : ''}.`;
+  if (e.status === 403 && b.error === 'insufficient_scope') return `The API key lacks the scope ${(b.missing || []).join(', ') || '(unknown)'}. Add it to the key in Blog Automation → Entwickler / API.`;
+  if (e.status === 404) return `Not found: ${b.message || 'the record does not exist or belongs to another account'}.`;
+  if (e.status === 429) return `Rate limit reached – try again in ${e.retryAfter || 60} seconds.`;
+  return `Blog Automation error ${e.status}${b.error ? ` (${b.error})` : ''}: ${b.message || 'unknown error'}`;
+}
+
+/** createClient({ apiKey, base?, fetch? }) → { get, post } */
+export function createClient({ apiKey, base = process.env.BA_API_BASE || DEFAULT_BASE, fetch: f = globalThis.fetch } = {}) {
+  const root = String(base).replace(/\/+$/, '');
+  async function call(method, path, { query, body, idempotent = false } = {}) {
+    if (!apiKey) throw new ApiError(401, { error: 'unauthorized', message: 'No API key.' });
+    const u = new URL(root + path);
+    for (const [k, v] of Object.entries(query || {})) if (v !== undefined && v !== null && v !== '') u.searchParams.set(k, String(v));
+    const headers = { Authorization: `Bearer ${apiKey}`, Accept: 'application/json', 'User-Agent': UA };
+    if (body !== undefined) headers['Content-Type'] = 'application/json';
+    if (idempotent) headers['Idempotency-Key'] = `mcp-${randomUUID()}`;
+    const r = await f(u, { method, headers, body: body !== undefined ? JSON.stringify(body) : undefined, signal: AbortSignal.timeout(180000) });
+    const text = await r.text();
+    let data; try { data = text ? JSON.parse(text) : {}; } catch { data = { error: 'invalid_response', message: text.slice(0, 200) }; }
+    if (!r.ok) throw new ApiError(r.status, data, r.headers);
+    return data;
+  }
+  return {
+    get: (path, query) => call('GET', path, { query }),
+    post: (path, body, opts = {}) => call('POST', path, { body: body ?? {}, ...opts }),
+  };
+}

package/src/cli.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+// blog-automation-mcp            → stdio, key from BA_API_KEY
+// blog-automation-mcp --http [--port 8787] [--host 127.0.0.1] [--origin https://claude.ai,...]  → streamable HTTP on /mcp, key per request
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { buildServer, createHttpServer, VERSION } from './server.js';
+import { KEY_RE } from './api.js';
+
+const argv = process.argv.slice(2);
+const opt = (name, d) => { const i = argv.indexOf(`--${name}`); return i >= 0 && argv[i + 1] && !argv[i + 1].startsWith('--') ? argv[i + 1] : d; };
+const err = (m) => process.stderr.write(`${m}\n`);   // stdout belongs to the MCP protocol
+
+if (argv.includes('--version')) { process.stdout.write(`${VERSION}\n`); process.exit(0); }
+if (argv.includes('--http')) {
+  const port = Number(opt('port', process.env.PORT || 8787)), host = opt('host', process.env.HOST || '127.0.0.1');
+  const origins = String(opt('origin', process.env.BA_MCP_ORIGINS || '')).split(',').map((s) => s.trim()).filter(Boolean);
+  createHttpServer({ origins, log: err }).listen(port, host, () => err(`Blog Automation MCP ${VERSION}: http://${host}:${port}/mcp (allowed browser origins: ${origins.join(', ') || 'none'})`));
+} else {
+  const apiKey = String(process.env.BA_API_KEY || '').trim();
+  if (!KEY_RE.test(apiKey)) { err('Set BA_API_KEY to your Blog Automation API key (ba_live_…, Blog Automation → Entwickler / API).'); process.exit(1); }
+  await buildServer({ apiKey }).connect(new StdioServerTransport());
+  err(`Blog Automation MCP ${VERSION} on stdio`);
+}

package/src/server.js

@@ -0,0 +1,59 @@
+// Blog Automation MCP server: buildServer() for any transport, createHttpServer() = streamable HTTP (stateless, key per request).
+import http from 'node:http';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { createClient, KEY_RE } from './api.js';
+import { registerTools } from './tools.js';
+
+export const VERSION = '1.0.1';
+const INSTRUCTIONS = 'Blog Automation plans, writes and publishes blog articles to WordPress. Typical flow: list_sites → list_ideas / create_idea → write_article (uses tokens – check token_balance and confirm) → article_status → publish_article (public – confirm). Article ids, idea ids and site ids are integers.';
+
+/** one MCP server bound to one API key */
+export function buildServer({ apiKey, base, fetch } = {}) {
+  const server = new McpServer({ name: 'blog-automation', title: 'Blog Automation', version: VERSION }, { instructions: INSTRUCTIONS });
+  registerTools(server, createClient({ apiKey, base, fetch }));
+  return server;
+}
+
+const send = (res, code, obj, headers = {}) => { res.writeHead(code, { 'Content-Type': 'application/json', ...headers }); res.end(JSON.stringify(obj)); };
+const rpcError = (res, code, message, headers) => send(res, code, { jsonrpc: '2.0', error: { code: -32000, message }, id: null }, headers);
+
+/**
+ * Streamable HTTP on /mcp. Stateless: every POST builds a fresh server with the key from "Authorization: Bearer ba_live_…".
+ * The key is only used for that request's API calls – not stored, not logged. Browsers: Origin must be in `origins` (DNS rebinding).
+ */
+export function createHttpServer({ base, fetch, origins = [], maxBody = 1024 * 1024, log = () => {} } = {}) {
+  const allowed = new Set(origins.map((o) => o.replace(/\/+$/, '').toLowerCase()));
+  return http.createServer(async (req, res) => {
+    const path = (req.url || '/').split('?')[0];
+    if (path === '/healthz') return send(res, 200, { ok: true, name: 'blog-automation-mcp', version: VERSION });
+    if (path !== '/mcp') return send(res, 404, { error: 'not_found' });
+    const origin = req.headers.origin;
+    if (origin && !allowed.has(String(origin).toLowerCase())) return rpcError(res, 403, 'Origin not allowed.');
+    const cors = origin ? { 'Access-Control-Allow-Origin': origin, Vary: 'Origin' } : {};
+    if (req.method === 'OPTIONS') {
+      res.writeHead(204, { ...cors, 'Access-Control-Allow-Methods': 'POST, OPTIONS', 'Access-Control-Allow-Headers': 'Authorization, Content-Type, Mcp-Protocol-Version, Accept', 'Access-Control-Max-Age': '600' });
+      return res.end();
+    }
+    if (req.method !== 'POST') return rpcError(res, 405, 'Method not allowed (stateless server: POST only).', { Allow: 'POST, OPTIONS', ...cors });
+    const m = /^Bearer\s+(\S+)$/i.exec(String(req.headers.authorization || ''));
+    if (!m || !KEY_RE.test(m[1])) return rpcError(res, 401, 'Send your Blog Automation API key: Authorization: Bearer ba_live_…', { 'WWW-Authenticate': 'Bearer realm="blog-automation"', ...cors });
+    let body;
+    try {
+      const chunks = []; let size = 0;
+      for await (const c of req) { size += c.length; if (size > maxBody) return rpcError(res, 413, 'Request too large.', cors); chunks.push(c); }
+      body = JSON.parse(Buffer.concat(chunks).toString('utf8') || 'null');
+    } catch { return rpcError(res, 400, 'Invalid JSON.', cors); }
+    for (const [k, v] of Object.entries(cors)) res.setHeader(k, v);
+    const server = buildServer({ apiKey: m[1], base, fetch });
+    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined, enableJsonResponse: true });
+    res.on('close', () => { transport.close().catch(() => {}); server.close().catch(() => {}); });
+    try {
+      await server.connect(transport);
+      await transport.handleRequest(req, res, body);
+    } catch (e) {
+      log(`mcp request failed: ${e?.message || e}`);   // never the key
+      if (!res.headersSent) rpcError(res, 500, 'Internal error.');
+    }
+  });
+}

package/src/tools.js

@@ -0,0 +1,119 @@
+// The MCP tools. Each maps to one Customer API endpoint (app repo: server/routes/ext.js). Results are JSON text + structuredContent.
+import { z } from 'zod';
+import { explain } from './api.js';
+
+const ok = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }], structuredContent: data });
+const fail = (e) => ({ isError: true, content: [{ type: 'text', text: e?.user ? e.message : explain(e) }] });
+const run = (fn) => async (args, extra) => { try { return ok(await fn(args || {}, extra || {})); } catch (e) { return fail(e); } };
+const sleep = (ms, signal) => new Promise((resolve, reject) => {
+  if (signal?.aborted) return reject(Object.assign(new Error('Cancelled.'), { user: true }));
+  const t = setTimeout(resolve, ms);
+  signal?.addEventListener('abort', () => { clearTimeout(t); reject(Object.assign(new Error('Cancelled.'), { user: true })); }, { once: true });
+});
+const small = (a) => { if (a) delete a.content; return a; };   // keep answers small – get_article returns the HTML
+/** tuning for tests */
+export const WAIT = { totalMs: 50000, everyMs: 3000 };
+const clean = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== undefined && v !== null && v !== ''));
+
+const id = z.number().int().positive();
+const limit = z.number().int().min(1).max(100).optional().describe('1–100, default 25');
+const cursor = z.string().optional().describe('nextCursor of the previous page');
+const READ = { readOnlyHint: true, openWorldHint: true };
+const ARTICLE_STATES = ['idea', 'draft', 'review', 'approved', 'scheduled', 'publishing', 'published', 'failed', 'archived'];
+
+/** register all tools on an McpServer, using the API client `api` */
+export function registerTools(server, api) {
+  server.registerTool('list_ideas', {
+    title: 'List ideas',
+    description: 'List the topic ideas on the Blog Automation idea board, newest first. Paginate with nextCursor.',
+    inputSchema: { status: z.enum(['new', 'planned', 'used', 'discarded']).optional(), siteId: id.optional(), limit, cursor },
+    annotations: READ,
+  }, run((a) => api.get('/ideas', clean(a))));
+
+  server.registerTool('create_idea', {
+    title: 'Create an idea',
+    description: 'Add a topic idea to the idea board (no tokens used). Automations and "write_article" with ideaId can turn it into an article later.',
+    inputSchema: {
+      title: z.string().min(1).max(300), keyword: z.string().max(300).optional().describe('focus keyword'), notes: z.string().max(2000).optional(),
+      audience: z.string().max(300).optional(), priority: z.number().int().min(1).max(3).optional().describe('1 = high … 3 = low'),
+      language: z.string().regex(/^[a-z]{2}$/).optional().describe('e.g. de, en'), siteId: id.optional(),
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+  }, run((a) => api.post('/ideas', clean(a), { idempotent: true })));
+
+  server.registerTool('write_article', {
+    title: 'Write an article with AI',
+    description: 'Write a complete blog article with AI (title, HTML, SEO fields, optional featured image). USES TOKENS of the Blog Automation account – check token_balance first and confirm with the user. Give a topic or keyword, or ideaId of an idea (needs scope ideas:write). The article is saved as a draft; publishing is a separate step (publish_article). Waits up to about 50 seconds; if the AI is still writing it returns a jobId – then call job_status later.',
+    inputSchema: {
+      topic: z.string().max(300).optional(), keyword: z.string().max(300).optional(), ideaId: id.optional(), templateId: z.string().optional().describe('e.g. b:howto – see list_templates'),
+      language: z.string().regex(/^[a-z]{2}$/).optional(), length: z.enum(['short', 'medium', 'long']).optional(), tone: z.string().max(100).optional(),
+      audience: z.string().max(300).optional(), siteId: id.optional().describe('target WordPress site – see list_sites'), withImage: z.boolean().optional().describe('also create a featured image (more tokens)'),
+      notes: z.string().max(2000).optional().describe('extra instructions for the AI'),
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+  }, run(async (a, extra) => {
+    if (!a.topic && !a.keyword && !a.ideaId) throw Object.assign(new Error('Give a topic, a keyword or an ideaId.'), { user: true });
+    // async mode: 202 { job } – writing can take minutes; wait ~50 s, then hand back the job id (job_status)
+    const r = await api.post('/articles/generate', { ...clean(a), async: true }, { idempotent: true });
+    if (!r.job) { small(r.article); return r; }   // app answered synchronously
+    let job = r.job;
+    const until = Date.now() + WAIT.totalMs;
+    while (job.status === 'running' && Date.now() < until) {
+      await sleep(WAIT.everyMs, extra.signal);
+      job = await api.get(`/jobs/${job.id}`);
+    }
+    if (job.status === 'done') return { done: true, jobId: job.id, article: small(job.article), tokens: job.tokens };
+    if (job.status === 'failed') throw Object.assign(new Error(`Writing the article failed: ${job.error?.message || job.error?.error || 'unknown error'} (job ${job.id}).`), { user: true });
+    return { done: false, jobId: job.id, status: job.status, hint: `The AI is still writing. Call job_status with id ${job.id} in a minute.` };
+  }));
+
+  server.registerTool('job_status', {
+    title: 'AI writing job status',
+    description: 'State of an AI writing job started by write_article: running, done (with the article) or failed (with the error).',
+    inputSchema: { id }, annotations: READ,
+  }, run(async (a) => { const j = await api.get(`/jobs/${a.id}`); small(j.article); return j; }));
+
+  server.registerTool('list_articles', {
+    title: 'List articles',
+    description: 'List articles, newest first, without the HTML. Filter by status (one or more of: idea, draft, review, approved, scheduled, publishing, published, failed, archived), site or title text.',
+    inputSchema: { status: z.array(z.enum(ARTICLE_STATES)).optional(), siteId: id.optional(), q: z.string().max(80).optional().describe('search in titles'), limit, cursor },
+    annotations: READ,
+  }, run((a) => api.get('/articles', clean({ ...a, status: a.status?.length ? a.status.join(',') : undefined }))));
+
+  server.registerTool('get_article', {
+    title: 'Get an article',
+    description: 'Read one article with its HTML content, SEO fields and publishing state.',
+    inputSchema: { id }, annotations: READ,
+  }, run((a) => api.get(`/articles/${a.id}`)));
+
+  server.registerTool('article_status', {
+    title: 'Article status',
+    description: 'Publishing status of an article: status, scheduled time, WordPress link, last error and the publishing job.',
+    inputSchema: { id }, annotations: READ,
+  }, run((a) => api.get(`/articles/${a.id}/status`)));
+
+  server.registerTool('publish_article', {
+    title: 'Publish or schedule an article',
+    description: 'Publish an article to its WordPress site now, or – with "at" – add it to the editorial calendar: an ISO 8601 time or "next" for the next free slot of the site. Approves a draft in the same step (needs scope articles:publish). This makes content public – confirm with the user first.',
+    inputSchema: { id, at: z.string().optional().describe('ISO 8601 date-time or "next"; empty = publish now'), siteId: id.optional() },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+  }, run((a) => (a.at ? api.post(`/articles/${a.id}/schedule`, clean({ at: a.at, siteId: a.siteId })) : api.post(`/articles/${a.id}/publish`, clean({ siteId: a.siteId })))));
+
+  server.registerTool('token_balance', {
+    title: 'Token balance',
+    description: 'Token balance of the Blog Automation account, open lots with expiry and the price of each AI action.',
+    inputSchema: {}, annotations: READ,
+  }, run(() => api.get('/tokens')));
+
+  server.registerTool('list_sites', {
+    title: 'List WordPress sites',
+    description: 'The connected WordPress sites with connection status, language and time zone (use the id as siteId).',
+    inputSchema: { limit, cursor }, annotations: READ,
+  }, run((a) => api.get('/sites', clean(a))));
+
+  server.registerTool('list_templates', {
+    title: 'List article templates',
+    description: 'Built-in (id b:…) and own article templates (use the id as templateId in write_article).',
+    inputSchema: { lang: z.enum(['en', 'de']).optional() }, annotations: READ,
+  }, run((a) => api.get('/templates', clean(a))));
+}