@motiblog/mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,1034 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/index.ts
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+
+// src/config.ts
+function loadConfig(env = process.env) {
+  const apiBaseUrl = (env.MOTIBLOG_API_URL || "http://localhost:3001").replace(/\/+$/, "");
+  const apiKey = env.MOTIBLOG_API_KEY?.trim();
+  if (!apiKey) {
+    throw new Error(
+      "MOTIBLOG_API_KEY is required. Get a per-project key from the MotiBlog dashboard (Project \u2192 Blog API) or via POST /projects/:id/blog-api/rotate."
+    );
+  }
+  return {
+    apiBaseUrl,
+    apiKey,
+    defaultProjectId: env.MOTIBLOG_PROJECT_ID?.trim() || void 0
+  };
+}
+
+// src/server.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+
+// src/api-client.ts
+var MotiblogApiError = class extends Error {
+  constructor(status, url, body, message) {
+    super(message);
+    this.status = status;
+    this.url = url;
+    this.body = body;
+    this.name = "MotiblogApiError";
+  }
+  status;
+  url;
+  body;
+};
+var MotiblogApiClient = class {
+  constructor(apiBaseUrl, apiKey, fetchImpl = fetch) {
+    this.apiBaseUrl = apiBaseUrl;
+    this.apiKey = apiKey;
+    this.fetchImpl = fetchImpl;
+  }
+  apiBaseUrl;
+  apiKey;
+  fetchImpl;
+  async request(method, path, opts = {}) {
+    const attempts = method === "GET" ? 2 : 1;
+    let lastErr;
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+      try {
+        return await this.requestOnce(method, path, opts);
+      } catch (err) {
+        lastErr = err;
+        if (err instanceof MotiblogApiError) throw err;
+        if (attempt === attempts) break;
+        await new Promise((r) => setTimeout(r, 400 * attempt));
+      }
+    }
+    throw lastErr;
+  }
+  async requestOnce(method, path, opts = {}) {
+    let url = `${this.apiBaseUrl}${path}`;
+    const search = new URLSearchParams();
+    for (const [k, v] of Object.entries(opts.query ?? {})) {
+      if (v !== void 0 && v !== "") search.set(k, String(v));
+    }
+    const qs = search.toString();
+    if (qs) url += `?${qs}`;
+    const res = await this.fetchImpl(url, {
+      method,
+      headers: {
+        "x-api-key": this.apiKey,
+        ...opts.body !== void 0 ? { "content-type": "application/json" } : {}
+      },
+      body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0
+    });
+    const text = await res.text();
+    let parsed;
+    try {
+      parsed = text ? JSON.parse(text) : void 0;
+    } catch {
+      parsed = text;
+    }
+    if (!res.ok) {
+      const bodyObj = parsed && typeof parsed === "object" ? parsed : {};
+      const validation = bodyObj.errors;
+      const detail = Array.isArray(bodyObj.message) ? bodyObj.message.join("; ") : typeof bodyObj.message === "string" ? bodyObj.message : typeof parsed === "string" && parsed ? parsed : `HTTP ${res.status}`;
+      const suffix = validation ? ` \u2014 ${JSON.stringify(validation)}` : "";
+      throw new MotiblogApiError(res.status, url, parsed, `${detail}${suffix}`);
+    }
+    if (parsed && typeof parsed === "object" && "data" in parsed) {
+      return parsed.data;
+    }
+    return parsed;
+  }
+  // ── Projects ───────────────────────────────────────────────────────────────
+  listProjects() {
+    return this.request("GET", "/projects");
+  }
+  getProject(projectId) {
+    return this.request("GET", `/projects/${projectId}`);
+  }
+  pipelineStart(projectId) {
+    return this.request("POST", `/projects/${projectId}/pipeline/start`);
+  }
+  pipelineStatus(projectId) {
+    return this.request("GET", `/projects/${projectId}/pipeline/status`);
+  }
+  // ── Content plans / topics ────────────────────────────────────────────────
+  createContentPlanFromGap(projectId, topic) {
+    return this.request("POST", `/projects/${projectId}/content-plans/from-gap`, {
+      body: { topic }
+    });
+  }
+  listContentPlans(projectId) {
+    return this.request("GET", `/projects/${projectId}/content-plans`);
+  }
+  approveContentPlan(projectId, planId) {
+    return this.request(
+      "PATCH",
+      `/projects/${projectId}/content-plans/${planId}/approve`
+    );
+  }
+  regenerateContentPlan(projectId, planId) {
+    return this.request(
+      "POST",
+      `/projects/${projectId}/content-plans/${planId}/regenerate`
+    );
+  }
+  generateArticleFromPlan(projectId, planId) {
+    return this.request(
+      "POST",
+      `/projects/${projectId}/content-plans/${planId}/generate`
+    );
+  }
+  getCalendar(projectId, start, end) {
+    return this.request("GET", `/projects/${projectId}/calendar`, {
+      query: { start, end }
+    });
+  }
+  // ── Articles ──────────────────────────────────────────────────────────────
+  listArticles(projectId, status) {
+    return this.request("GET", `/projects/${projectId}/articles`, {
+      query: { status }
+    });
+  }
+  getArticle(projectId, articleId) {
+    return this.request("GET", `/projects/${projectId}/articles/${articleId}`);
+  }
+  updateArticle(projectId, articleId, patch) {
+    return this.request("PATCH", `/projects/${projectId}/articles/${articleId}`, {
+      body: patch
+    });
+  }
+  scheduleArticle(projectId, articleId, scheduledFor) {
+    return this.request(
+      "PATCH",
+      `/projects/${projectId}/articles/${articleId}/schedule`,
+      { body: { scheduledFor } }
+    );
+  }
+  approveAndPublish(projectId, articleId) {
+    return this.request(
+      "POST",
+      `/projects/${projectId}/articles/${articleId}/approve-and-publish`
+    );
+  }
+  regenerateArticle(projectId, articleId) {
+    return this.request(
+      "POST",
+      `/projects/${projectId}/articles/${articleId}/regenerate`
+    );
+  }
+  regenerateChapter(projectId, articleId, chapterIndex) {
+    return this.request(
+      "POST",
+      `/projects/${projectId}/articles/${articleId}/regenerate-chapter`,
+      { body: { chapterIndex } }
+    );
+  }
+  getPipelineLogs(projectId, articleId) {
+    return this.request(
+      "GET",
+      `/projects/${projectId}/articles/${articleId}/pipeline-logs`
+    );
+  }
+  listRefreshSuggestions() {
+    return this.request("GET", "/articles/refresh-suggestions");
+  }
+  // ── Integrations / publishing ─────────────────────────────────────────────
+  listIntegrations(projectId) {
+    return this.request("GET", `/projects/${projectId}/integrations`);
+  }
+  createIntegration(projectId, dto) {
+    return this.request("POST", `/projects/${projectId}/integrations`, { body: dto });
+  }
+  testIntegration(projectId, integrationId, mode) {
+    return this.request(
+      "POST",
+      `/projects/${projectId}/integrations/${integrationId}/test`,
+      { query: { mode } }
+    );
+  }
+  publishToIntegration(projectId, articleId, integrationId) {
+    return this.request(
+      "POST",
+      `/projects/${projectId}/articles/${articleId}/publish/${integrationId}`
+    );
+  }
+  retryPublish(projectId, articleId, integrationId) {
+    return this.request(
+      "POST",
+      `/projects/${projectId}/articles/${articleId}/publish/${integrationId}/retry`
+    );
+  }
+  listPublishLogs(projectId, articleId, limit) {
+    const base = articleId ? `/projects/${projectId}/articles/${articleId}/publish-logs` : `/projects/${projectId}/publish-logs`;
+    return this.request("GET", base, { query: { limit } });
+  }
+  // ── Keywords & proprietary facts (agent-supplied knowledge) ───────────────
+  addKeyword(projectId, dto) {
+    return this.request("POST", `/projects/${projectId}/keywords`, { body: dto });
+  }
+  listKeywords(projectId) {
+    return this.request("GET", `/projects/${projectId}/keywords`);
+  }
+  listProductFacts(projectId, activeOnly) {
+    return this.request("GET", `/projects/${projectId}/proprietary-facts`, {
+      query: { active: activeOnly ? "true" : void 0 }
+    });
+  }
+  createProductFact(projectId, dto) {
+    return this.request("POST", `/projects/${projectId}/proprietary-facts`, {
+      body: dto
+    });
+  }
+  updateProductFact(projectId, factId, dto) {
+    return this.request(
+      "PATCH",
+      `/projects/${projectId}/proprietary-facts/${factId}`,
+      { body: dto }
+    );
+  }
+};
+
+// src/tools.ts
+var import_zod = require("zod");
+
+// src/export.ts
+var import_fs = require("fs");
+var import_path = require("path");
+
+// ../../packages/shared/src/constants/index.ts
+var PLAN = {
+  name: "MotiBlog Pro",
+  articlesPerMonth: 30,
+  originalPrice: 99,
+  monthly: { price: 39, interval: "month" },
+  yearly: { price: 390, interval: "year", monthlyEquivalent: 32.5, savings: 78 },
+  features: [
+    "30 articles a month, 2,500-4,000 words each",
+    "Keyword research from competitor gap analysis",
+    "Internal links woven in before every publish",
+    "Publishes to WordPress, Webflow, Ghost, Shopify and more",
+    "Search Console positions and impressions",
+    "Competitor tracking",
+    "Up to 10 projects",
+    "Support by email"
+  ]
+};
+var PLANS = {
+  PRO: { name: PLAN.name, articlesPerMonth: PLAN.articlesPerMonth, projects: 10, price: PLAN.monthly.price }
+};
+
+// ../../packages/shared/src/export/article-markdown.ts
+function attr(tag, name) {
+  const m = tag.match(new RegExp(`${name}\\s*=\\s*["']([^"']*)["']`, "i"));
+  return m?.[1] ?? "";
+}
+function embedSrcToWatchUrl(src) {
+  const yt = src.match(/youtube(?:-nocookie)?\.com\/embed\/([A-Za-z0-9_-]{5,})/i);
+  if (yt) return `https://www.youtube.com/watch?v=${yt[1]}`;
+  const vimeo = src.match(/player\.vimeo\.com\/video\/(\d+)/i);
+  if (vimeo) return `https://vimeo.com/${vimeo[1]}`;
+  return src;
+}
+function outsideCodeFences(content, transform) {
+  const parts = content.split(/(```[\s\S]*?```|~~~[\s\S]*?~~~)/);
+  return parts.map((part, i) => i % 2 === 1 ? part : transform(part)).join("");
+}
+function convertHtmlImages(chunk) {
+  return chunk.replace(/<img\b[^>]*\/?>(?:\s*<\/img>)?/gi, (tag) => {
+    const src = attr(tag, "src");
+    if (!src) return "";
+    const alt = attr(tag, "alt");
+    return `![${alt}](${src})`;
+  });
+}
+function convertIframes(chunk) {
+  return chunk.replace(
+    /<iframe\b[^>]*>[\s\S]*?<\/iframe>|<iframe\b[^>]*\/>/gi,
+    (tag) => {
+      const src = attr(tag, "src");
+      if (!src) return "";
+      const url = embedSrcToWatchUrl(src);
+      return `[\u25B6 Watch the video](${url})`;
+    }
+  );
+}
+function enforceSingleH1(body) {
+  const withoutLeading = body.replace(/^\s*#(?!#)[^\n]*\n+/, "");
+  return withoutLeading.replace(/^#(?!#)\s?/gm, "## ");
+}
+function articleToMarkdown(article) {
+  const converted = outsideCodeFences(
+    article.content ?? "",
+    (chunk) => convertIframes(convertHtmlImages(chunk))
+  );
+  const body = enforceSingleH1(converted).trim();
+  return `# ${article.title}
+
+${body}
+`;
+}
+
+// src/export.ts
+function slugify(input, fallback) {
+  const slug = input.toLowerCase().normalize("NFKD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 120);
+  return slug || fallback;
+}
+function yamlString(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function buildArticleMarkdown(article) {
+  const frontmatter = ["---"];
+  frontmatter.push(`title: ${yamlString(article.title)}`);
+  frontmatter.push(`slug: ${yamlString(article.slug)}`);
+  if (article.metaDescription) {
+    frontmatter.push(`description: ${yamlString(article.metaDescription)}`);
+  }
+  if (article.publishedAt) {
+    frontmatter.push(`publishedAt: ${yamlString(String(article.publishedAt))}`);
+  }
+  if (article.topics?.length) {
+    frontmatter.push("tags:");
+    for (const topic of article.topics) {
+      frontmatter.push(`  - ${yamlString(topic)}`);
+    }
+  }
+  if (article.bannerUrl) {
+    frontmatter.push(`banner: ${yamlString(String(article.bannerUrl))}`);
+  }
+  if (typeof article.seoScore === "number") {
+    frontmatter.push(`seoScore: ${article.seoScore}`);
+  }
+  if (article.wordCount !== void 0 && article.wordCount !== null) {
+    frontmatter.push(`wordCount: ${article.wordCount}`);
+  }
+  frontmatter.push(`motiblogArticleId: ${yamlString(article.id)}`);
+  frontmatter.push("---", "");
+  return `${frontmatter.join("\n")}
+${articleToMarkdown({
+    title: article.title,
+    content: article.content ?? ""
+  })}`;
+}
+async function exportArticlesToDir(outDirInput, articles) {
+  const outDir = (0, import_path.resolve)(outDirInput);
+  await import_fs.promises.mkdir(outDir, { recursive: true });
+  const files = [];
+  let skipped = 0;
+  for (const article of articles) {
+    if (!article.content || !article.content.trim()) {
+      skipped += 1;
+      continue;
+    }
+    const slug = slugify(article.slug || article.title, `article-${article.id}`);
+    const dir = (0, import_path.join)(outDir, slug);
+    await import_fs.promises.mkdir(dir, { recursive: true });
+    const file = (0, import_path.join)(dir, "index.md");
+    await import_fs.promises.writeFile(file, buildArticleMarkdown(article), "utf8");
+    files.push({
+      path: file,
+      articleId: article.id,
+      slug,
+      title: article.title
+    });
+  }
+  const manifest = {
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    count: files.length,
+    skippedEmptyContent: skipped,
+    articles: files.map((f) => ({
+      file: f.path,
+      articleId: f.articleId,
+      slug: f.slug,
+      title: f.title
+    }))
+  };
+  await import_fs.promises.writeFile(
+    (0, import_path.join)(outDir, "manifest.json"),
+    JSON.stringify(manifest, null, 2),
+    "utf8"
+  );
+  return { outDir, files, skipped };
+}
+
+// src/tools.ts
+var ARTICLE_STATUSES = [
+  "DRAFT",
+  "GENERATING",
+  "REVIEW",
+  "APPROVED",
+  "PUBLISHING",
+  "PUBLISHED",
+  "FAILED",
+  "SKIPPED"
+];
+var projectIdArg = {
+  project_id: import_zod.z.string().optional().describe("MotiBlog project id. Omit when MOTIBLOG_PROJECT_ID is configured.")
+};
+function json(value) {
+  return { text: JSON.stringify(value, null, 2) };
+}
+function resolveProjectId(ctx, raw) {
+  const id = typeof raw === "string" && raw.trim() || ctx.defaultProjectId;
+  if (!id) {
+    throw new Error(
+      "No project specified: pass project_id or set the MOTIBLOG_PROJECT_ID environment variable."
+    );
+  }
+  return id;
+}
+function summarizeArticleForList(a) {
+  return {
+    id: a.id,
+    title: a.title,
+    slug: a.slug,
+    status: a.status,
+    wordCount: a.wordCount,
+    seoScore: a.seoScore,
+    scheduledFor: a.scheduledFor ?? null,
+    publishedAt: a.publishedAt ?? null,
+    topics: a.topics ?? []
+  };
+}
+function buildDigest(input, now = /* @__PURE__ */ new Date()) {
+  const { project, articles, plans } = input;
+  const statusCounts = {};
+  for (const a of articles) statusCounts[a.status] = (statusCounts[a.status] ?? 0) + 1;
+  const reviewQueue = articles.filter((a) => a.status === "REVIEW").map((a) => ({ id: a.id, title: a.title, wordCount: a.wordCount }));
+  const sevenDaysAgo = now.getTime() - 7 * 24 * 3600 * 1e3;
+  const publishedLast7Days = articles.filter((a) => a.publishedAt && new Date(a.publishedAt).getTime() >= sevenDaysAgo).sort((a, b) => new Date(b.publishedAt).getTime() - new Date(a.publishedAt).getTime()).map((a) => ({ title: a.title, publishedAt: String(a.publishedAt) }));
+  const in7Days = now.getTime() + 7 * 24 * 3600 * 1e3;
+  const plansNext7Days = plans.filter(
+    (p) => p.scheduledDate && new Date(p.scheduledDate).getTime() >= now.getTime() - 24 * 3600 * 1e3 && new Date(p.scheduledDate).getTime() <= in7Days && p.status !== "COMPLETED"
+  ).sort((a, b) => String(a.scheduledDate).localeCompare(String(b.scheduledDate))).map((p) => ({
+    date: String(p.scheduledDate).slice(0, 10),
+    title: p.title,
+    status: p.status
+  }));
+  const latest = publishedLast7Days[0] ?? null;
+  return {
+    project: {
+      id: project.id,
+      name: project.name,
+      autonomy: project.autoPublish ? "L2 \u2014 auto-publish clean, review exceptions" : "L1 \u2014 drafts daily, publish only via agent review",
+      quota: { used: project.articlesUsed ?? 0, limit: project.articlesLimit ?? 0 }
+    },
+    articles: statusCounts,
+    reviewQueue,
+    publishedLast7Days,
+    plansNext7Days,
+    latestPublished: latest ? { title: latest.title, at: latest.publishedAt } : null,
+    checkedAt: now.toISOString()
+  };
+}
+var toolDefinitions = [
+  // ── Discovery ──────────────────────────────────────────────────────────────
+  {
+    name: "get_digest",
+    description: "One-call morning check-in for a project: article counts by lifecycle status, the REVIEW queue (what is waiting to be published, with word counts), posts published in the last 7 days, content plans due in the next 7 days, the latest published post, quota usage, and the project's current autonomy level (L1 = nothing ships without agent review; L2 = clean articles auto-publish). Start every check-in here.",
+    inputSchema: { ...projectIdArg },
+    annotations: { readOnlyHint: true },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      const [project, articles, plans] = await Promise.all([
+        ctx.client.getProject(projectId),
+        ctx.client.listArticles(projectId),
+        ctx.client.listContentPlans(projectId)
+      ]);
+      return json(
+        buildDigest({ project, articles, plans })
+      );
+    }
+  },
+  {
+    name: "list_projects",
+    description: "List every MotiBlog project the API key can access, with settings that matter to agents: requireApproval (REVIEW vs APPROVED after generation), autoPublish, factCheckStrict, selfHostedBlog, and article quota usage.",
+    inputSchema: {},
+    annotations: { readOnlyHint: true },
+    async handler(_args, ctx) {
+      return json(await ctx.client.listProjects());
+    }
+  },
+  {
+    name: "get_project",
+    description: "Get one MotiBlog project in detail: pipeline settings (aiModel, language, internalLinks, banner), positioning inputs (businessProfile, productTruth, manualPositioning) and quota state.",
+    inputSchema: { ...projectIdArg },
+    annotations: { readOnlyHint: true },
+    async handler(args, ctx) {
+      return json(await ctx.client.getProject(resolveProjectId(ctx, args.project_id)));
+    }
+  },
+  // ── Pipeline / generation ops ─────────────────────────────────────────────
+  {
+    name: "start_pipeline",
+    description: "Start the autonomous pipeline for a project: site crawl/analysis \u2192 topic selection \u2192 article generation for scheduled plans. Returns immediately; poll get_pipeline_status or list_articles(status=GENERATING) to follow progress.",
+    inputSchema: { ...projectIdArg },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      return json(await ctx.client.pipelineStart(projectId));
+    }
+  },
+  {
+    name: "get_pipeline_status",
+    description: "Get current pipeline run state for a project: whether a run is active, its steps, and recent run history. Use after start_pipeline or generate_article.",
+    inputSchema: { ...projectIdArg },
+    annotations: { readOnlyHint: true },
+    async handler(args, ctx) {
+      return json(
+        await ctx.client.pipelineStatus(resolveProjectId(ctx, args.project_id))
+      );
+    }
+  },
+  // ── Topics & planning ─────────────────────────────────────────────────────
+  {
+    name: "suggest_topics",
+    description: "Suggest blog topics for a project by adding entries to its content plan (one call per topic). This is the agent-side 'propose' step: topics land as DRAFT plan entries \u2014 nothing is generated until you approve_content_plan + generate_article. Prefer specific, keyword-like topics.",
+    inputSchema: {
+      topic: import_zod.z.string().min(1).describe('The proposed topic/title, e.g. "How headless CMSs serve AI agents"'),
+      ...projectIdArg
+    },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      return json(await ctx.client.createContentPlanFromGap(projectId, String(args.topic)));
+    }
+  },
+  {
+    name: "list_content_plans",
+    description: "List the content plan queue for a project with each entry status: DRAFT (proposed), APPROVED (cleared for generation), IN_PROGRESS, COMPLETED.",
+    inputSchema: { ...projectIdArg },
+    annotations: { readOnlyHint: true },
+    async handler(args, ctx) {
+      return json(await ctx.client.listContentPlans(resolveProjectId(ctx, args.project_id)));
+    }
+  },
+  {
+    name: "approve_content_plan",
+    description: "Approve a DRAFT content-plan entry so it becomes eligible for generation (generate_article or the scheduled pipeline).",
+    inputSchema: {
+      plan_id: import_zod.z.string().describe("Content plan entry id (from list_content_plans)"),
+      ...projectIdArg
+    },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      return json(await ctx.client.approveContentPlan(projectId, String(args.plan_id)));
+    }
+  },
+  {
+    name: "regenerate_content_plan",
+    description: "Ask AI to rewrite a content-plan entry (new title/summary/target keyword) \u2014 use when a suggested topic misses the mark. Only works while no article has been generated from it.",
+    inputSchema: {
+      plan_id: import_zod.z.string().describe("Content plan entry id"),
+      ...projectIdArg
+    },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      return json(await ctx.client.regenerateContentPlan(projectId, String(args.plan_id)));
+    }
+  },
+  {
+    name: "generate_article",
+    description: "Generate an article from an APPROVED content-plan entry via the full pipeline (research \u2192 outline \u2192 draft \u2192 fact-check \u2192 polish \u2192 scoring). Returns the article in GENERATING state; review later via get_article once status reaches REVIEW or APPROVED.",
+    inputSchema: {
+      plan_id: import_zod.z.string().describe("Content plan entry id (must be APPROVED)"),
+      ...projectIdArg
+    },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      return json(await ctx.client.generateArticleFromPlan(projectId, String(args.plan_id)));
+    }
+  },
+  {
+    name: "get_calendar",
+    description: "Get scheduled content-plan entries (with slim article previews) between two ISO dates, e.g. start_date=2026-09-01 end_date=2026-09-30.",
+    inputSchema: {
+      start_date: import_zod.z.string().describe("ISO date, e.g. 2026-09-01"),
+      end_date: import_zod.z.string().describe("ISO date, e.g. 2026-09-30"),
+      ...projectIdArg
+    },
+    annotations: { readOnlyHint: true },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      return json(
+        await ctx.client.getCalendar(
+          projectId,
+          String(args.start_date),
+          String(args.end_date)
+        )
+      );
+    }
+  },
+  // ── Review loop ───────────────────────────────────────────────────────────
+  {
+    name: "list_review_queue",
+    description: `List articles awaiting attention, filtered by status. Lifecycle: DRAFT \u2192 GENERATING \u2192 REVIEW \u2192 APPROVED \u2192 PUBLISHING \u2192 PUBLISHED (also FAILED, SKIPPED). Default status=REVIEW (needs human/agent approval); pass APPROVED to see what is cleared for publishing.`,
+    inputSchema: {
+      status: import_zod.z.enum(ARTICLE_STATUSES).optional().describe("Filter by lifecycle status (default REVIEW)"),
+      ...projectIdArg
+    },
+    annotations: { readOnlyHint: true },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      const status = typeof args.status === "string" ? args.status : "REVIEW";
+      const articles = await ctx.client.listArticles(projectId, status);
+      return json(articles.map(summarizeArticleForList));
+    }
+  },
+  {
+    name: "get_article",
+    description: "Get the FULL article: markdown content plus quality signals \u2014 factCheckReport (verified/unverified claims with sources), topicGate verdict, seoScore/issues, publishedUrl. Set include_logs=true to append per-phase pipeline telemetry (tokens, cost, phase status). Use this during review before approving publication.",
+    inputSchema: {
+      article_id: import_zod.z.string().describe("Article id"),
+      include_logs: import_zod.z.boolean().optional().describe("Include pipeline phase logs (default false)"),
+      ...projectIdArg
+    },
+    annotations: { readOnlyHint: true },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      const article = await ctx.client.getArticle(projectId, String(args.article_id));
+      let logs = void 0;
+      if (args.include_logs === true) {
+        logs = await ctx.client.getPipelineLogs(projectId, String(args.article_id));
+      }
+      return json(logs ? { article, pipelineLogs: logs } : article);
+    }
+  },
+  {
+    name: "update_article",
+    description: "Edit an article: replace the markdown content, retitle, change metaDescription, or move status (e.g. fix flagged claims from factCheckReport then set status=APPROVED; or send back to DRAFT). Editing content is how agents answer fact-check flags when no external source exists.",
+    inputSchema: {
+      article_id: import_zod.z.string().describe("Article id"),
+      content: import_zod.z.string().optional().describe("Full replacement markdown body"),
+      title: import_zod.z.string().max(500).optional(),
+      meta_description: import_zod.z.string().max(320).optional(),
+      status: import_zod.z.enum(["DRAFT", "REVIEW", "APPROVED"]).optional(),
+      ...projectIdArg
+    },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      const patch = {};
+      if (typeof args.content === "string") patch.content = args.content;
+      if (typeof args.title === "string") patch.title = args.title;
+      if (typeof args.meta_description === "string") patch.metaDescription = args.meta_description;
+      if (typeof args.status === "string") patch.status = args.status;
+      return json(await ctx.client.updateArticle(projectId, String(args.article_id), patch));
+    }
+  },
+  {
+    name: "approve_publication",
+    description: "Approve an article for publication through the governed approval gate. publish_now=true also triggers publishing immediately (to enabled integrations, or the self-hosted blog when selfHostedBlog=true). Otherwise the article sits in APPROVED until the scheduler/autoPublish picks it up or publish_to_integration is called.",
+    inputSchema: {
+      article_id: import_zod.z.string().describe("Article id (must be in REVIEW/APPROVED/DRAFT-eligible state)"),
+      publish_now: import_zod.z.boolean().optional().describe("Also trigger publishing now (default false)"),
+      ...projectIdArg
+    },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      const articleId = String(args.article_id);
+      if (args.publish_now === true) {
+        return json(await ctx.client.approveAndPublish(projectId, articleId));
+      }
+      return json(await ctx.client.updateArticle(projectId, articleId, { status: "APPROVED" }));
+    }
+  },
+  {
+    name: "schedule_publication",
+    description: "Set or clear a per-article scheduled publish time (ISO datetime). Pass null for clear_schedule=true to unschedule. Scheduled APPROVED articles are published automatically by the 15-minute scheduler when autoPublish is on.",
+    inputSchema: {
+      article_id: import_zod.z.string().describe("Article id"),
+      scheduled_for: import_zod.z.string().optional().describe("ISO datetime, e.g. 2026-09-01T09:00:00Z"),
+      clear_schedule: import_zod.z.boolean().optional().describe("Clear any scheduled date instead of setting one"),
+      ...projectIdArg
+    },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      const value = args.clear_schedule === true ? null : args.scheduled_for ?? null;
+      return json(await ctx.client.scheduleArticle(projectId, String(args.article_id), value));
+    }
+  },
+  // ── Regeneration ops ──────────────────────────────────────────────────────
+  {
+    name: "regenerate_article",
+    description: "Wipe an article and rerun the ENTIRE pipeline from scratch (research \u2192 draft \u2026). Content-destructive: prefer update_article for targeted edits or regenerate_chapter for one section.",
+    inputSchema: {
+      article_id: import_zod.z.string().describe("Article id"),
+      ...projectIdArg
+    },
+    annotations: { destructiveHint: true },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      return json(await ctx.client.regenerateArticle(projectId, String(args.article_id)));
+    }
+  },
+  {
+    name: "regenerate_chapter",
+    description: "Regenerate ONE chapter (0-based chapter_index) of an article; all other sections stay byte-identical. Cheaper and safer than regenerate_article.",
+    inputSchema: {
+      article_id: import_zod.z.string().describe("Article id"),
+      chapter_index: import_zod.z.number().int().min(0).describe("Zero-based chapter index"),
+      ...projectIdArg
+    },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      return json(
+        await ctx.client.regenerateChapter(
+          projectId,
+          String(args.article_id),
+          Number(args.chapter_index)
+        )
+      );
+    }
+  },
+  {
+    name: "get_pipeline_logs",
+    description: "Per-phase pipeline telemetry for one article: phase names, statuses, messages, token counts, and USD cost per phase. Diagnose FAILED articles or audit what the generator did.",
+    inputSchema: {
+      article_id: import_zod.z.string().describe("Article id"),
+      ...projectIdArg
+    },
+    annotations: { readOnlyHint: true },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      return json(await ctx.client.getPipelineLogs(projectId, String(args.article_id)));
+    }
+  },
+  {
+    name: "list_refresh_suggestions",
+    description: "Across ALL your projects: published articles whose Search Console stats suggest they are decaying and would benefit from a refresh. Feed these back into planning via suggest_topics or update_article.",
+    inputSchema: {},
+    annotations: { readOnlyHint: true },
+    async handler(_args, ctx) {
+      return json(await ctx.client.listRefreshSuggestions());
+    }
+  },
+  // ── Publishing targets ────────────────────────────────────────────────────
+  {
+    name: "list_integrations",
+    description: "List configured publishing targets (integrations) for a project: WEBHOOK, WORDPRESS, GHOST, WEBFLOW, SHOPIFY, DEVTO, SANITY, CUSTOM_API \u2014 with enabled state.",
+    inputSchema: { ...projectIdArg },
+    annotations: { readOnlyHint: true },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      const integrations = await ctx.client.listIntegrations(projectId);
+      return json(integrations.map((i) => ({ ...i, config: "<redacted>" })));
+    }
+  },
+  {
+    name: "create_webhook_integration",
+    description: "Register a webhook publishing target: MotiBlog POSTs the published article JSON to your endpoint (signed with X-Signature: sha256=<HMAC(secret)> when secret is set). Config shape: { url, secret?, method? }. This is how an agent's own infrastructure receives content pushes.",
+    inputSchema: {
+      name: import_zod.z.string().min(1).max(100).describe('Display name, e.g. "my-site deploy hook"'),
+      url: import_zod.z.string().url().describe("HTTPS endpoint receiving the article payload"),
+      secret: import_zod.z.string().optional().describe("HMAC secret used to sign deliveries"),
+      method: import_zod.z.enum(["POST", "PUT", "PATCH"]).optional().describe("HTTP method (default POST)"),
+      ...projectIdArg
+    },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      const config = { url: String(args.url) };
+      if (typeof args.secret === "string") config.secret = args.secret;
+      if (typeof args.method === "string") config.method = args.method;
+      return json(
+        await ctx.client.createIntegration(projectId, {
+          type: "WEBHOOK",
+          name: String(args.name),
+          config,
+          enabled: true
+        })
+      );
+    }
+  },
+  {
+    name: "test_integration",
+    description: "Test a publishing target connection. mode=ping (default) checks credentials/reachability only; mode=full may create and clean up a test item on the target.",
+    inputSchema: {
+      integration_id: import_zod.z.string().describe("Integration id"),
+      mode: import_zod.z.enum(["ping", "full"]).optional(),
+      ...projectIdArg
+    },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      return json(
+        await ctx.client.testIntegration(
+          projectId,
+          String(args.integration_id),
+          typeof args.mode === "string" ? args.mode : void 0
+        )
+      );
+    }
+  },
+  {
+    name: "publish_to_integration",
+    description: "Push an APPROVED article to one specific integration now (enqueues the publish job; transitions APPROVED \u2192 PUBLISHING \u2192 PUBLISHED). Check results via list_publish_logs.",
+    inputSchema: {
+      article_id: import_zod.z.string().describe("Article id (should be APPROVED)"),
+      integration_id: import_zod.z.string().describe("Target integration id"),
+      ...projectIdArg
+    },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      return json(
+        await ctx.client.publishToIntegration(
+          projectId,
+          String(args.article_id),
+          String(args.integration_id)
+        )
+      );
+    }
+  },
+  {
+    name: "retry_publish",
+    description: "Retry a failed publish attempt for an article/integration pair.",
+    inputSchema: {
+      article_id: import_zod.z.string(),
+      integration_id: import_zod.z.string(),
+      ...projectIdArg
+    },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      return json(
+        await ctx.client.retryPublish(
+          projectId,
+          String(args.article_id),
+          String(args.integration_id)
+        )
+      );
+    }
+  },
+  {
+    name: "list_publish_logs",
+    description: "Publishing history: SUCCESS/FAILED attempts with publishedUrl, provider error text and timestamps. Pass article_id for one article, or omit for the whole project (limit defaults server-side).",
+    inputSchema: {
+      article_id: import_zod.z.string().optional(),
+      limit: import_zod.z.number().int().min(1).max(200).optional(),
+      ...projectIdArg
+    },
+    annotations: { readOnlyHint: true },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      return json(
+        await ctx.client.listPublishLogs(
+          projectId,
+          typeof args.article_id === "string" ? args.article_id : void 0,
+          typeof args.limit === "number" ? args.limit : void 0
+        )
+      );
+    }
+  },
+  // ── Agent-supplied knowledge ───────────────────────────────────────────────
+  {
+    name: "list_keywords",
+    description: "List tracked keywords for a project (search volume, difficulty, intent, status). Keywords drive topic relevance in generation.",
+    inputSchema: { ...projectIdArg },
+    annotations: { readOnlyHint: true },
+    async handler(args, ctx) {
+      return json(await ctx.client.listKeywords(resolveProjectId(ctx, args.project_id)));
+    }
+  },
+  {
+    name: "add_keyword",
+    description: "Track a new SEO keyword for a project so future topic suggestions/generation can target it. intent is one of INFORMATIONAL, NAVIGATIONAL, TRANSACTIONAL, COMMERCIAL.",
+    inputSchema: {
+      keyword: import_zod.z.string().min(1).describe("The keyword phrase"),
+      search_volume: import_zod.z.number().int().min(0).optional(),
+      difficulty: import_zod.z.number().int().min(0).max(100).optional(),
+      intent: import_zod.z.enum(["INFORMATIONAL", "NAVIGATIONAL", "TRANSACTIONAL", "COMMERCIAL"]).optional(),
+      ...projectIdArg
+    },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      return json(
+        await ctx.client.addKeyword(projectId, {
+          keyword: String(args.keyword),
+          ...typeof args.search_volume === "number" ? { searchVolume: args.search_volume } : {},
+          ...typeof args.difficulty === "number" ? { difficulty: args.difficulty } : {},
+          ...typeof args.intent === "string" ? { intent: args.intent } : {}
+        })
+      );
+    }
+  },
+  {
+    name: "list_product_facts",
+    description: "List the project proprietary facts \u2014 ground-truth statements about the product (features, pricing, integrations) injected into prompts and enforced by strict fact-checking.",
+    inputSchema: {
+      active_only: import_zod.z.boolean().optional().describe("Only active facts (default false = all)"),
+      ...projectIdArg
+    },
+    annotations: { readOnlyHint: true },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      return json(
+        await ctx.client.listProductFacts(projectId, args.active_only === true)
+      );
+    }
+  },
+  {
+    name: "supply_product_fact",
+    description: "Supply a ground-truth fact about the customer's product (or update one via fact_id). Strict fact-checking uses these to verify claims; supply facts BEFORE generation for best results. Example: fact='Acme integrates natively with Shopify since v2.3', category=['integrations'].",
+    inputSchema: {
+      fact: import_zod.z.string().min(1).describe("A single verifiable statement of product truth"),
+      category: import_zod.z.array(import_zod.z.string()).optional().describe('Tags, e.g. ["pricing","features"]'),
+      fact_id: import_zod.z.string().optional().describe("Existing fact id to UPDATE instead of create"),
+      active: import_zod.z.boolean().optional().describe("Set active flag when updating"),
+      ...projectIdArg
+    },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      const category = Array.isArray(args.category) ? args.category.map(String) : void 0;
+      if (typeof args.fact_id === "string") {
+        return json(
+          await ctx.client.updateProductFact(projectId, args.fact_id, {
+            ...typeof args.fact === "string" ? { fact: args.fact } : {},
+            ...category ? { category } : {},
+            ...typeof args.active === "boolean" ? { active: args.active } : {}
+          })
+        );
+      }
+      return json(
+        await ctx.client.createProductFact(projectId, {
+          fact: String(args.fact),
+          ...category ? { category } : {}
+        })
+      );
+    }
+  },
+  // ── Export (deploy-it-yourself) ───────────────────────────────────────────
+  {
+    name: "export_blog",
+    description: "Export articles out of MotiBlog to local files so you can deploy them yourself into any codebase (Astro/Next/Jekyll/Hugo/plain git). Writes {out_dir}/{slug}/index.md with YAML frontmatter (title, slug, description, tags, publishedAt, banner, motiblogArticleId) + portable GitHub-Flavored-Markdown body, plus manifest.json. Default exports PUBLISHED posts; pass status to export drafts for review.",
+    inputSchema: {
+      out_dir: import_zod.z.string().min(1).describe("Directory to write into (created if missing; relative paths resolve against the MCP server cwd)"),
+      status: import_zod.z.enum(ARTICLE_STATUSES).optional().describe("Which lifecycle stage to export (default PUBLISHED)"),
+      limit: import_zod.z.number().int().min(1).max(500).optional().describe("Max articles to export (default 100)"),
+      ...projectIdArg
+    },
+    async handler(args, ctx) {
+      const projectId = resolveProjectId(ctx, args.project_id);
+      const status = typeof args.status === "string" ? args.status : "PUBLISHED";
+      const limit = typeof args.limit === "number" ? args.limit : 100;
+      const summaries = await ctx.client.listArticles(projectId, status);
+      const selected = summaries.slice(0, limit);
+      const articles = [];
+      for (const summary of selected) {
+        articles.push(await ctx.client.getArticle(projectId, summary.id));
+      }
+      const result = await exportArticlesToDir(String(args.out_dir), articles);
+      return json({
+        exportedTo: result.outDir,
+        count: result.files.length,
+        skippedEmpty: result.skipped,
+        files: result.files.map((f) => f.path),
+        nextStep: "Commit/copy this folder into your target codebase. Each folder is self-contained static content ready for any SSG."
+      });
+    }
+  }
+];
+
+// src/server.ts
+function buildServer(config) {
+  const client = new MotiblogApiClient(config.apiBaseUrl, config.apiKey);
+  const server = new import_mcp.McpServer(
+    { name: "motiblog", version: "0.1.0" },
+    {
+      instructions: "MotiBlog: agent-operated blog content engine. Typical loop: list_projects \u2192 suggest_topics / list_content_plans \u2192 approve_content_plan \u2192 generate_article \u2192 list_review_queue + get_article (check factCheckReport & seoScore) \u2192 update_article if fixes are needed \u2192 approve_publication \u2192 publish_to_integration or export_blog to ship content to your own codebase. Publication always passes the governed approval gate \u2014 there is no bypass."
+    }
+  );
+  const register = server.registerTool.bind(server);
+  for (const tool of toolDefinitions) {
+    register(
+      tool.name,
+      {
+        title: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        ...tool.annotations ? { annotations: tool.annotations } : {}
+      },
+      async (args) => {
+        let result;
+        try {
+          result = await tool.handler(args ?? {}, {
+            client,
+            defaultProjectId: config.defaultProjectId
+          });
+        } catch (err) {
+          result = {
+            text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+            isError: true
+          };
+        }
+        return {
+          content: [{ type: "text", text: result.text }],
+          ...result.isError ? { isError: true } : {}
+        };
+      }
+    );
+  }
+  return server;
+}
+
+// src/index.ts
+async function main() {
+  const config = loadConfig();
+  const server = buildServer(config);
+  await server.connect(new import_stdio.StdioServerTransport());
+}
+main().catch((err) => {
+  console.error("[motiblog-mcp] fatal:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map