@bettercms-ai/mcp 0.54.1 → 0.55.0

package/dist/index.js

@@ -2574,7 +2574,20 @@ var LISTING_TAIL = /* @__PURE__ */ new Set([
   "deploy_from_upload",
   "set_authoring_preference",
   "set_media_delivery",
-  "delete_form_submission"
+  "delete_form_submission",
+  // The ABM campaign lane: a marketer's dashboard surface, plus the worker tools a task runner
+  // claims with. Ten more tools than the tail was written for, and a connector that truncates
+  // would otherwise lose `get_deploy_status` and the GitHub lane to make room for them.
+  "research_account",
+  "claim_abm_task",
+  "complete_abm_task",
+  "fail_abm_task",
+  "get_campaign_review",
+  "regenerate_entry",
+  "approve_campaign_entries",
+  "publish_campaign",
+  "get_campaign_share_link",
+  "revoke_campaign_share_link"
 ]);
 function buildToolDefs(deps) {
   async function withClient(fn) {
@@ -3852,7 +3865,7 @@ ${res.warnings.join("\n")}` : summary, res.data);
       def(
         "generate_pages_from_dataset",
         "Generate many pages from a dataset",
-        "Turn a dataset into many pages at once (programmatic SEO from a keyword list, or ABM pages from an account list). Give a template `pageId`, a `mapping` (contentModelId, a slugTemplate like 'for-{{company}}', and per-field values that are either a column name or {ai:{prompt}}), and `rows`. ALWAYS call with dryRun:true first and show the sample \u2014 a real run parks for approval and must be released with approve_ai_job.",
+        "Turn a dataset into many pages at once (programmatic SEO from a keyword list, or ABM pages from an account list). Give a template `pageId`, a `mapping` (contentModelId, a slugTemplate like 'for-{{company}}', and per-field values that are either a column name or {ai:{prompt}}), and `rows`. For an ABM campaign set `mapping.campaign.id` and the run fans out across every page that campaign owns, returning one job id per page in `jobIds`. ALWAYS call with dryRun:true first and show the sample \u2014 a real run parks for approval and must be released with approve_ai_job.",
         z.object({
           pageId: z.string().min(1),
           mapping: z.record(z.string(), z.unknown()),
@@ -3861,6 +3874,121 @@ ${res.warnings.join("\n")}` : summary, res.data);
         }).shape,
         async (c, a) => ok("Generation queued.", await data(c, "POST", `/management/bulk/generate`, { pageId: a.pageId, mapping: a.mapping, rows: a.rows, dryRun: a.dryRun }))
       ),
+      def(
+        "research_account",
+        "Research one account",
+        "Read one company's public site into a cited brief the page generator can use: what they do, who they sell to, what they say is hard, with a source URL on every fact. `lite` is one fetch and costs nothing extra; `deep` searches the web, costs 3 credits and is capped per day. A brief less than 30 days old is returned from cache for free. Company-scoped by design: it never stores a person, an email or a job title.",
+        z.object({
+          campaignId: z.string().min(1),
+          domain: z.string().min(1),
+          name: z.string().optional(),
+          mode: z.enum(["lite", "deep"]).optional(),
+          force: z.boolean().optional()
+        }).shape,
+        async (c, a) => ok("Account brief.", await data(c, "POST", `/management/campaigns/research`, { campaignId: a.campaignId, domain: a.domain, name: a.name, mode: a.mode, force: a.force }))
+      ),
+      def(
+        "claim_abm_task",
+        "Claim an account to research",
+        "Claim the next account of a campaign that is waiting for YOU to research it. Returns the account, a `taskId` and a `leaseToken` good for ten minutes; `null` means there is nothing left and your loop is done. Research the company however you like, then call complete_abm_task with the brief \u2014 or fail_abm_task if you cannot. Never store a person, an email or a job title: the brief is refused if you do.",
+        z.object({ campaignId: z.string().min(1), agentId: z.string().optional() }).shape,
+        async (c, a) => ok("Claimed task.", await data(c, "POST", `/management/campaigns/${s(a.campaignId)}/tasks/claim`, { agentId: a.agentId }))
+      ),
+      def(
+        "complete_abm_task",
+        "Hand back an account brief",
+        "Hand back the brief for a task you claimed. `brief` is {name, domain, industry?, size?, painPoint?, summary?, facts:[{text, sourceUrl}], logo?, brandColors?} and NOTHING else \u2014 an unknown key is refused with brief_invalid and the path. Every fact needs the URL it came from. When the campaign's last task is done the page generation starts on its own.",
+        z.object({
+          campaignId: z.string().min(1),
+          taskId: z.string().min(1),
+          leaseToken: z.string().min(1),
+          brief: z.record(z.string(), z.unknown())
+        }).shape,
+        async (c, a) => ok("Brief accepted.", await data(c, "POST", `/management/campaigns/${s(a.campaignId)}/tasks/${s(a.taskId)}/complete`, { leaseToken: a.leaseToken, brief: a.brief }))
+      ),
+      def(
+        "fail_abm_task",
+        "Give an account task back",
+        "Give a claimed task back when you cannot research the account \u2014 the site is down, there is nothing public to read, the domain is wrong. The page is still written, from the dataset alone, and says so.",
+        z.object({
+          campaignId: z.string().min(1),
+          taskId: z.string().min(1),
+          leaseToken: z.string().min(1),
+          reason: z.string().optional()
+        }).shape,
+        async (c, a) => ok("Task returned.", await data(c, "POST", `/management/campaigns/${s(a.campaignId)}/tasks/${s(a.taskId)}/fail`, { leaseToken: a.leaseToken, reason: a.reason }))
+      ),
+      def(
+        "get_campaign_review",
+        "Review a campaign's pages",
+        "The campaign's generated pages, SORTED BY DOUBT \u2014 flagged first, then least confident. Each row carries its flags (`unsupported_claim:headline` and the like), the claims the model said it made, which fields it wrote, and a preview link for drafts. `filter:'flagged'` is the review queue; `sample:5` is the first look at a big run; `filter:'failed'` lists the rows that produced no page at all and why.",
+        z.object({
+          campaignId: z.string().min(1),
+          filter: z.enum(["all", "flagged", "pending", "approved", "rejected", "low_confidence", "failed"]).optional(),
+          sample: z.number().optional(),
+          pageId: z.string().optional(),
+          runId: z.string().optional(),
+          cursor: z.string().optional(),
+          limit: z.number().optional()
+        }).shape,
+        async (c, a) => ok("Campaign review.", await data(c, "GET", `/management/campaigns/${s(a.campaignId)}/review${q({ filter: a.filter, sample: a.sample, pageId: a.pageId, runId: a.runId, cursor: a.cursor, limit: a.limit })}`))
+      ),
+      def(
+        "regenerate_entry",
+        "Rewrite one account's page",
+        "Rewrite ONE account's page, optionally with an instruction ('lead with the integration story') and optionally only certain fields. Costs one credit and writes a DRAFT \u2014 a published page shows unpublished changes until someone publishes it again. Re-runs from the original spreadsheet row, not from the last answer, so repeated regenerates do not drift.",
+        z.object({
+          campaignId: z.string().min(1),
+          entryId: z.string().min(1),
+          instruction: z.string().optional(),
+          fields: z.array(z.string()).optional()
+        }).shape,
+        async (c, a) => ok("Regeneration queued.", await data(c, "POST", `/management/campaigns/${s(a.campaignId)}/entries/${s(a.entryId)}/regenerate`, { instruction: a.instruction, fields: a.fields }))
+      ),
+      def(
+        "approve_campaign_entries",
+        "Mark campaign pages reviewed",
+        "Mark campaign pages reviewed. `entryIds:'all_unflagged'` clears every page with nothing wrong with it, which is most of them; a FLAGGED page must be named explicitly, because approving one is a person saying they checked the claim. Approving does not publish \u2014 publish_campaign does, and it refuses pages that are still flagged.",
+        z.object({
+          campaignId: z.string().min(1),
+          entryIds: z.union([z.array(z.string()), z.literal("all_unflagged")]),
+          status: z.enum(["approved", "rejected"]),
+          note: z.string().optional()
+        }).shape,
+        async (c, a) => ok("Entries reviewed.", await data(c, "POST", `/management/campaigns/${s(a.campaignId)}/entries/review`, { entryIds: a.entryIds, status: a.status, note: a.note }))
+      ),
+      def(
+        "publish_campaign",
+        "Publish a campaign",
+        "Put a campaign's pages on the internet, or schedule them. `confirm: true` is REQUIRED \u2014 this is the one action in the ABM lane that a human, not you, decides. It REFUSES with `entry_flagged` if any page still carries an unchecked claim (call get_campaign_review and approve them first) and with `blueprint_missing_disclaimer` if a campaign page has lost its 'not affiliated with' band. Pages somebody rejected are skipped and counted.",
+        z.object({
+          campaignId: z.string().min(1),
+          scheduledAt: z.string().optional(),
+          unpublishAt: z.string().optional(),
+          confirm: z.boolean()
+        }).shape,
+        async (c, a) => ok("Campaign publish queued.", await data(c, "POST", `/management/campaigns/${s(a.campaignId)}/publish`, { scheduledAt: a.scheduledAt, unpublishAt: a.unpublishAt, confirm: a.confirm }))
+      ),
+      def(
+        "get_campaign_share_link",
+        "Make a share link",
+        "Make a link a rep can send before the pages are published. `scope:'campaign'` opens the whole account index; `scope:'account'` with an `externalKey` (the account's domain) opens exactly that account's pages and 404s on anyone else's. At most 14 days, revocable, rate-limited and noindex. The link's `uses` is how a rep sees Not sent / Sent / Visited.",
+        z.object({
+          campaignId: z.string().min(1),
+          scope: z.enum(["campaign", "account"]).optional(),
+          externalKey: z.string().optional(),
+          expiresIn: z.string().optional(),
+          label: z.string().optional()
+        }).shape,
+        async (c, a) => ok("Share link.", await data(c, "POST", `/management/campaigns/${s(a.campaignId)}/share-links`, { scope: a.scope, externalKey: a.externalKey, expiresIn: a.expiresIn, label: a.label }))
+      ),
+      def(
+        "revoke_campaign_share_link",
+        "Withdraw a share link",
+        "Withdraw ONE share link by its `jti`, leaving every other link to the same campaign working. The link then answers 404. Safe to call twice.",
+        z.object({ campaignId: z.string().min(1), jti: z.string().min(1) }).shape,
+        async (c, a) => ok("Share link revoked.", await data(c, "DELETE", `/management/campaigns/${s(a.campaignId)}/share-links/${s(a.jti)}`))
+      ),
       def(
         "list_ai_jobs",
         "List bulk jobs",
@@ -3871,7 +3999,7 @@ ${res.warnings.join("\n")}` : summary, res.data);
       def(
         "get_ai_job",
         "Get a bulk job",
-        "One bulk job \u2014 status, rows processed, rows created, conflicts, and the approval plan if it is still parked.",
+        "One bulk job \u2014 its `type` (generate, seo, rename, migrate, publish, unpublish, research), status, rows processed, rows created, conflicts, and the approval plan if it is still parked. `rowResults` is the per-row ledger: every row that FAILED or was skipped, with a reason code, which is the only place \u201C20 rows in, 18 pages out\u201D is explained. `summary` splits a rerun into added / updated / unchanged, and `campaignId` / `collectionSlug` say which campaign and collection the pages landed in.",
         z.object({ jobId: z.string().min(1) }).shape,
         async (c, a) => ok("Bulk job.", await data(c, "GET", `/management/bulk/jobs/${s(a.jobId)}`))
       ),
@@ -5928,16 +6056,31 @@ End-to-end authoring from a repo or a brief. Confirm-first at every stage.
    apply via \`set_page_content\` / \`create_content_entry\` / \`update_content_entry\`.
 3. **SEO** \u2014 run the SEO flow to fill metaTitle/metaDescription for each page.
 Never invent brand facts \u2014 ask the user for anything the repo/brief doesn't state.`;
-var LANDING_PAGES_FLOW = `### Generate landing pages (programmatic SEO / ABM) \u2192 \`write_content\` + \`create_content_entry\` + \`generate_seo_meta\`
+var LANDING_PAGES_FLOW = `### Generate landing pages (programmatic SEO / ABM) \u2192 \`generate_pages_from_dataset\`
 Spin up many pages sharing one template, each personalized per row (company, keyword, persona).
-1. **Template** \u2014 ensure a dynamic page or content model exists for the template
-   (\`create_page\` pageType 'dynamic' / \`create_content_model\`); its fields are the per-page slots.
-2. **Dataset** \u2014 get the list of targets from the user (rows of variables, e.g. company + industry).
-3. **Per row (loop)** \u2014 draft each slot with \`write_content\` (the row's variables as the brief/
-   \`context\`), pick a unique slug, then \`create_content_entry\` { contentModelId, data, slug, status }.
-   Add SEO with \`generate_seo_meta\` on the drafted copy and store it on the entry.
-Confirm the first 1\u20132 rows with the user before generating the rest. For hundreds of rows,
-the dashboard AI Page Builder bulk-imports a CSV \u2014 mention it.`;
+
+For an ABM campaign \u2014 a page per NAMED COMPANY \u2014 the whole flow is eight steps, in this order:
+1. **Research** \u2014 \`research_account\` per account, or set \`mapping.campaign.research\` and let the
+   run do it ('lite' reads the company's own site, 'deep' searches the web, 'agent' hands the work
+   to YOU through \`claim_abm_task\` / \`complete_abm_task\`).
+2. **Generate** \u2014 \`generate_pages_from_dataset\` with \`mapping.campaign = { id, research,
+   externalKeyColumn: 'domain' }\`. It fans out across every page the campaign owns and parks for
+   approval. Re-running the same export UPDATES each account's page rather than duplicating it.
+3. **Approve the job** \u2014 \`approve_ai_job\`, only once the user has said yes.
+4. **Review** \u2014 \`get_campaign_review\` with \`sample: 5\`, then \`filter: 'flagged'\`. A flag reads
+   \`unsupported_claim:headline\`: a figure that is in none of the account's own facts, so the field
+   fell back to the blueprint's copy. \`filter: 'failed'\` lists rows that produced no page at all.
+5. **Regenerate** \u2014 \`regenerate_entry\` with an instruction, one row at a time.
+6. **Approve entries** \u2014 \`approve_campaign_entries\`; \`'all_unflagged'\` clears the rest in one call.
+   A FLAGGED page must be named explicitly: approving one says a person checked the claim.
+7. **Publish** \u2014 \`publish_campaign\` with \`confirm: true\`. It refuses \`entry_flagged\` while any
+   page carries an unresolved flag, and \`blueprint_missing_disclaimer\` if a page has lost its
+   "not affiliated with" band. The user decides this step, never you.
+8. **Share** \u2014 \`get_campaign_share_link\` for a link a rep can send before publishing.
+
+For a plain programmatic-SEO run (a page per keyword, no named companies) the same tool works
+with no \`campaign\`, and \`write_content\` + \`create_content_entry\` per row is still fine for a
+handful. ALWAYS dry-run first and show the sample.`;
 var SEO_FLOW = `### Optimize SEO \u2192 \`generate_seo_meta\` + the page/entry update tools
 Fill or refresh SEO metadata across the site.
 1. **Target** \u2014 pick the pages/entries (\`list_pages\` / \`list_content_entries\`); confirm scope with the user.
@@ -6221,7 +6364,7 @@ Confirm each stage with the user before writing. On 401/403, the MCP key needs (
     "generate_landing_pages",
     {
       title: "Generate landing pages (programmatic SEO / ABM)",
-      description: "Spin up many personalized landing pages from one template + a dataset, drafting each page's copy with write_content and SEO with generate_seo_meta.",
+      description: "Spin up many personalized landing pages from one template + a dataset. For ABM (a page per named company) this is the research -> generate -> review -> approve -> publish -> share order.",
       argsSchema: {
         request: z2.string().optional().describe("the campaign, e.g. 'a page per target company for our ABM push'")
       }