@extenshi/mcp 0.10.0 → 0.11.0

package/dist/tools.js

@@ -40,6 +40,7 @@ import { buildDevelopmentGuide, GUIDE_SECTIONS } from './development-guide.js';
 import { DEFAULT_EXCERPT_CHARS, DocsError, getDocsIndex, MAX_EXCERPT_CHARS, MIN_EXCERPT_CHARS, searchDocs, } from './docs.js';
 import { renderIconWorkflow } from './icon-workflow.js';
 import { LANDING_LIMITS } from './landing-page.js';
+import { LANDING_FONTS, LANDING_SECTION_TYPES, LANDING_UI_DEFAULTS, LANDING_V2_LIMITS, } from './landing-sections.js';
 import { hostedLandingNextSteps, landingFormFromArgs, renderGenerateLandingPage } from './landing-workflow.js';
 import { renderLocalizeWorkflow } from './localize-workflow.js';
 import { PAY_OPERATIONS, paySchemas } from './pay.js';
@@ -95,7 +96,7 @@ export const SERVER_INSTRUCTIONS = 'Extenshi helps develop and operate browser e
     'Read get_decisions early: the AMO add-on id, license, seller identity and pricing are owner decisions — ' +
     'propose defaults with propose_decision; the owner decides them in Dojo, and release readiness blocks on them. ' +
     'Use list_extension_templates before the manifest, ' +
-    'and get_project_scaffold for a new project. Preserve existing source. For an existing extension, read get_project_workspace then preview and apply import_manifest to fill Dojo from its real manifest and default-locale messages before configuring services. Review the integration diff and preserve local edits; write integration.file ' +
+    'and get_project_scaffold for a new project. Preserve existing source. For an existing extension, read get_project_workspace then preview and apply import_manifest to fill Dojo from its real manifest and its _locales messages (messagesByLocale) before configuring services. Review the integration diff and preserve local edits; write integration.file ' +
     'verbatim to integration.path, check integration.unwired and re-read state after cabinet edits. ' +
     'Check get_credit_balance before metered work. get_risk_by_store_ids covers up to 40 store IDs ' +
     'for one read; get_security costs three reads for detailed findings. Hosted policy tools require ' +
@@ -584,6 +585,58 @@ const TOOL_ANNOTATIONS = {
         idempotentHint: true,
         openWorldHint: true,
     },
+    draft_landing_page: {
+        title: 'Draft a homepage from project state',
+        readOnlyHint: true,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+    preview_landing_page: {
+        title: 'Preview and validate a homepage',
+        readOnlyHint: true,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+    list_landing_page_versions: {
+        title: 'List homepage versions',
+        readOnlyHint: true,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+    rollback_landing_page: {
+        title: 'Restore an earlier homepage version',
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: false,
+        openWorldHint: true,
+    },
+    get_custom_domain: {
+        title: 'Read the custom domain setup',
+        readOnlyHint: true,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+    set_custom_domain: {
+        title: 'Add a custom domain',
+        readOnlyHint: false,
+        idempotentHint: true,
+        destructiveHint: false,
+        openWorldHint: true,
+    },
+    verify_custom_domain: {
+        title: 'Verify a custom domain',
+        readOnlyHint: false,
+        idempotentHint: true,
+        destructiveHint: false,
+        openWorldHint: true,
+    },
+    remove_custom_domain: {
+        title: 'Remove the custom domain',
+        readOnlyHint: false,
+        idempotentHint: true,
+        destructiveHint: true,
+        openWorldHint: true,
+    },
     unpublish_landing_page: {
         title: 'Unpublish the hosted landing page',
         readOnlyHint: false,
@@ -591,6 +644,52 @@ const TOOL_ANNOTATIONS = {
         destructiveHint: true,
         openWorldHint: true,
     },
+    get_install_instructions: {
+        title: 'Read the hosted install instructions',
+        readOnlyHint: true,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+    publish_install_instructions: {
+        title: 'Publish install instructions on extenshi.io',
+        readOnlyHint: false,
+        idempotentHint: true,
+        destructiveHint: false,
+        openWorldHint: true,
+    },
+    unpublish_install_instructions: {
+        title: 'Unpublish the hosted install instructions',
+        readOnlyHint: false,
+        idempotentHint: true,
+        destructiveHint: true,
+        openWorldHint: true,
+    },
+    get_page_translations: {
+        title: 'Read uninstall / welcome page translations',
+        readOnlyHint: true,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+    set_page_translations: {
+        title: 'Save translations of an uninstall / welcome page',
+        readOnlyHint: false,
+        idempotentHint: true,
+        destructiveHint: false,
+        openWorldHint: true,
+    },
+    get_legal_translations: {
+        title: 'Read privacy policy / license terms translations',
+        readOnlyHint: true,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+    set_legal_translations: {
+        title: 'Save translations of the privacy policy / license terms',
+        readOnlyHint: false,
+        idempotentHint: true,
+        destructiveHint: false,
+        openWorldHint: true,
+    },
     upload_project_media: {
         title: 'Upload a public image for hosted pages',
         readOnlyHint: false,
@@ -606,6 +705,120 @@ const TOOL_ANNOTATIONS = {
         openWorldHint: true,
     },
 };
+const hex = z.string().max(9);
+const palette = z
+    .object({
+    accent: hex.optional(),
+    accentText: hex.optional(),
+    background: hex.optional(),
+    surface: hex.optional(),
+    text: hex.optional(),
+    muted: hex.optional(),
+    border: hex.optional(),
+})
+    .optional();
+const FONT_IDS = Object.keys(LANDING_FONTS);
+/**
+ * Schema v2 of the landing form (shared-types/landing-sections.ts): a full,
+ * declarative homepage. Only read when schemaVersion is 2; a form without it
+ * renders exactly as before. Section contents are checked by the shared
+ * landingFormProblems, so the errors here, in the CLI and on the server match.
+ */
+const LANDING_V2_SHAPE = {
+    schemaVersion: z
+        .literal(2)
+        .optional()
+        .describe('2 builds a full homepage from sections, theme tokens, SEO and locales. Absent: the classic ' +
+        'one-screen page (unchanged output). draft_landing_page returns a complete v2 form.'),
+    sections: z
+        .array(z
+        .object({
+        id: z
+            .string()
+            .max(LANDING_V2_LIMITS.sectionId)
+            .describe('Lowercase slug, unique; also the locale override key.'),
+        type: z.enum(LANDING_SECTION_TYPES),
+        hidden: z.boolean().optional().describe('Keep in the form, leave out of the page.'),
+        title: z.string().max(LANDING_V2_LIMITS.title).optional(),
+        intro: z.string().max(LANDING_V2_LIMITS.intro).optional(),
+    })
+        .passthrough())
+        .max(LANDING_V2_LIMITS.sections)
+        .optional()
+        .describe('Ordered page sections (v2). Fields per type: ' +
+        'hero {headline?, subheadline?, showBadges?}; about {body — plain text, blank line = new paragraph}; ' +
+        'features {items: [{title, description?}]}; screenshots {items: [{url, alt, caption?}]} (hosted: ' +
+        'upload_project_media URLs or store screenshots); how-it-works {steps: [{title, description?}]}; ' +
+        'pricing {plans: [{name?, price?, period? one-time|month|year|lifetime, description?, features?, ' +
+        "highlighted?, offerSku?, ctaLabel?, ctaUrl?}], note?} — offerSku binds the plan to the project's " +
+        'Extenshi Pay offer so price and period come from the live offer; faq {items: [{question, answer}]} ' +
+        '(also emitted as FAQPage JSON-LD); testimonials {items: [{quote, author, role?, sourceUrl, ' +
+        'sourceLabel?}]} — real, attributed quotes only: author and a public https sourceUrl are required; ' +
+        'store-badges {browsers?: [chrome|firefox|edge]}; changelog {entries: [{version, ' +
+        'date? YYYY-MM-DD, notes: [string]}]}; links {items?: [{label, url}], includeProjectLinks?}. ' +
+        'Plain text only everywhere — no HTML, no scripts.'),
+    tokens: z
+        .object({
+        mode: z
+            .enum(['light', 'dark', 'auto'])
+            .optional()
+            .describe('auto ships both palettes (prefers-color-scheme).'),
+        light: palette,
+        dark: palette,
+        headingFont: z.enum(FONT_IDS).optional(),
+        bodyFont: z.enum(FONT_IDS).optional(),
+        radius: z.enum(['none', 'small', 'medium', 'large']).optional(),
+        width: z.enum(['narrow', 'normal', 'wide']).optional(),
+    })
+        .optional()
+        .describe('Theme tokens (v2): hex colours per mode and fonts from a system-font allowlist (no web fonts — the ' +
+        'hosted CSP loads nothing external). Poor contrast is reported as a warning.'),
+    seo: z
+        .object({
+        title: z.string().max(LANDING_V2_LIMITS.seoTitle).optional(),
+        description: z.string().max(LANDING_V2_LIMITS.seoDescription).optional(),
+        ogImageUrl: z.string().max(LANDING_LIMITS.url).optional(),
+        twitterSite: z.string().max(16).optional(),
+        authorName: z.string().max(120).optional(),
+        noindex: z.boolean().optional(),
+    })
+        .optional()
+        .describe('SEO / Open Graph (v2): <title>, meta description, og:image, twitter:site, JSON-LD author.'),
+    defaultLocale: z.string().max(35).optional().describe('Locale of the base content (default en).'),
+    locales: z
+        .record(z.string().max(35), z
+        .object({
+        extensionName: z.string().max(LANDING_LIMITS.extensionName).optional(),
+        tagline: z.string().max(LANDING_LIMITS.tagline).optional(),
+        description: z.string().max(LANDING_LIMITS.description).optional(),
+        seo: z
+            .object({ title: z.string().optional(), description: z.string().optional() })
+            .passthrough()
+            .optional(),
+        ui: z.record(z.string(), z.string().max(120)).optional(),
+        sections: z.record(z.string(), z.record(z.string(), z.unknown())).optional(),
+    })
+        .passthrough())
+        .optional()
+        .describe('Translations (v2), keyed by locale (de, pt-BR or the _locales spelling pt_BR; hosted pages accept ' +
+        'store locales). Each is served at {url}/{locale} with hreflang alternates. sections.{id} mirrors ' +
+        "that section's shape; only strings are taken (arrays merge by index), so a translation cannot " +
+        'change structure. ui overrides built-in headings and button labels.'),
+    ui: z
+        .record(z.string(), z.string().max(LANDING_V2_LIMITS.shortText))
+        .optional()
+        .describe(`Built-in strings to override (v2): ${Object.keys(LANDING_UI_DEFAULTS).join(', ')}.`),
+    uninstallUrl: z
+        .string()
+        .max(LANDING_LIMITS.url)
+        .optional()
+        .describe('Hosted uninstall feedback form URL (footer, v2).'),
+    termsUrl: z
+        .string()
+        .max(LANDING_LIMITS.url)
+        .optional()
+        .describe('License terms & refunds URL (footer, v2).'),
+};
 /**
  * LandingForm fields shared by generate_landing_page (offline HTML) and
  * publish_landing_page (hosted on page.extenshi.io). Limits match the builder
@@ -685,6 +898,7 @@ const LANDING_FORM_SHAPE = {
         .max(LANDING_LIMITS.logoUrl)
         .optional()
         .describe('Logo image as an https URL, a relative path, or a data:image/(png|jpeg|gif|webp);base64 URL.'),
+    ...LANDING_V2_SHAPE,
 };
 /**
  * Register the Extenshi tools once on a FastMCP server.
@@ -761,7 +975,7 @@ export function registerTools(server, deps) {
         }
         add({
             name: 'import_manifest',
-            description: 'Import an existing manifest.json into the Dojo manifest editor and project labels. Input: parsed JSON and optional default-locale messages. Source import fills supported fields and preserves all other JSON; built imports remain separate observations. Default dryRun=true returns changes and expectedStateHash without writing; dryRun=false with that hash applies them. Does not infer data collection, prices, or publication. Requires project.write.' +
+            description: 'Import an existing manifest.json into the Dojo manifest editor and project labels. Input: parsed JSON, optional default-locale messages, and optional messagesByLocale — every _locales/<lang>/messages.json keyed by locale code (only the keys named by the __MSG_*__ fields of the manifest are needed) — whose non-default locales fill the Dojo translations of name and description. Repository translations replace editor text per field; translations the repository lacks are kept, and warnings name each replaced one. Source import fills supported fields and preserves all other JSON; built imports remain separate observations. Default dryRun=true returns changes and expectedStateHash without writing; dryRun=false with that hash applies them. Does not infer data collection, prices, or publication. Requires project.write.' +
                 PROVENANCE_HINT,
             parameters: importManifestSchema,
             annotations: { readOnlyHint: false, idempotentHint: true, destructiveHint: true, openWorldHint: true },
@@ -990,8 +1204,11 @@ export function registerTools(server, deps) {
             name: 'publish_landing_page',
             description: "Publish the project's landing page (homepage) on Extenshi hosting — the same page " +
                 'generate_landing_page returns, rendered server-side from the form (no caller HTML is stored) and ' +
-                'served at page.extenshi.io/{code}, or https://{custom-domain}/landing when the project has an ' +
-                'active custom domain. The code is permanent: republishing creates a new version at the same URL. ' +
+                "served at page.extenshi.io/{code}, or at the root of the project's custom domain once it is ACTIVE " +
+                '(set_custom_domain). A schema-v2 form (schemaVersion 2; draft_landing_page returns one, ' +
+                'preview_landing_page validates it) adds sections, theme tokens, SEO, per-locale pages at {url}/{locale} with ' +
+                'hreflang, and llms.txt; pricing plans with offerSku take price and period from the live Pay offer. ' +
+                'The code is permanent: republishing creates a new version at the same URL. ' +
                 'By default the URL is also registered as the project homepage, which feeds HOMEPAGE_URL. Hosted ' +
                 'images are limited to store screenshot URLs (from get_extension) and images uploaded in the Dojo ' +
                 'Page generator or with upload_project_media (use its url for local screenshots or a logo); the logo ' +
@@ -1050,6 +1267,341 @@ export function registerTools(server, deps) {
                 }
             },
         });
+        add({
+            name: 'draft_landing_page',
+            description: 'Draft a full homepage (schema v2) from what the project already knows: the manifest draft and its ' +
+                'store translations, the published page or saved Page generator form, public project media, ' +
+                'Extenshi Pay offers (pricing plans bound by SKU), hosted artifacts (privacy policy, uninstall ' +
+                'feedback form, license terms, support page) and the workspace release/locales. Writes nothing. ' +
+                'Returns JSON {form, sources (field → where it came from), todos (what only you can supply — ' +
+                'features, how-it-works, real testimonials, translations), problems, previewUrl}. The form is ' +
+                'accepted as-is by preview_landing_page and publish_landing_page. storeUrls fills the install ' +
+                'buttons when the project does not know its listings yet. Requires project.read.',
+            parameters: z.object({
+                projectId: z.string().uuid(),
+                storeUrls: z
+                    .object({
+                    chrome: z.string().url().max(2000).optional(),
+                    firefox: z.string().url().max(2000).optional(),
+                    edge: z.string().url().max(2000).optional(),
+                })
+                    .optional()
+                    .describe('Store listing URLs, when the project does not have them yet.'),
+            }),
+            execute: async (args, context) => {
+                try {
+                    return JSON.stringify(await bff(context).draftLandingPage(args));
+                }
+                catch (err) {
+                    return readError(err, missingKeyMessage);
+                }
+            },
+        });
+        add({
+            name: 'preview_landing_page',
+            description: 'Validate and render a landing form exactly as publish_landing_page would — same image rules, ' +
+                'store-locale check, Pay offer prices and canonical URL — without publishing. Returns JSON ' +
+                '{ok, problems: [{path, severity, message, fix}], html (the page for `locale`), url, locales, ' +
+                'bytes, contentHash, llmsTxt, warnings}. `ok: false` means publish would refuse the form; every ' +
+                'problem says what to change. `html` is byte-for-byte the page publish would serve. ' +
+                'Requires project.read.',
+            parameters: z.object({
+                projectId: z.string().uuid(),
+                locale: z
+                    .string()
+                    .max(35)
+                    .optional()
+                    .describe('Which locale page to return (default the default locale).'),
+                ...LANDING_FORM_SHAPE,
+            }),
+            execute: async (args, context) => {
+                const { projectId, locale, ...fields } = args;
+                try {
+                    return JSON.stringify(await bff(context).previewLandingPage({
+                        projectId,
+                        locale,
+                        form: landingFormFromArgs(fields),
+                    }));
+                }
+                catch (err) {
+                    return readError(err, missingKeyMessage);
+                }
+            },
+        });
+        add({
+            name: 'list_landing_page_versions',
+            description: 'Version history of the hosted landing page, newest first: versionNumber, createdAt, contentHash, ' +
+                'reason (publish | rollback | domain — a canonical switch after the custom domain changed), ' +
+                'restoredFromVersion, schemaVersion, locales and which one is live. Requires project.read.',
+            parameters: z.object({ projectId: z.string().uuid() }),
+            execute: async (args, context) => {
+                try {
+                    return JSON.stringify(await bff(context).listLandingVersions(args));
+                }
+                catch (err) {
+                    return readError(err, missingKeyMessage);
+                }
+            },
+        });
+        add({
+            name: 'rollback_landing_page',
+            description: 'Restore an earlier version of the hosted landing page. History stays append-only: the old form ' +
+                "is published as a NEW version, re-rendered with today's URL and Pay offer prices. Returns the " +
+                'same JSON as publish_landing_page. Requires hosted.write.',
+            parameters: z.object({
+                projectId: z.string().uuid(),
+                versionNumber: z.number().int().min(1),
+                registerAsHomepage: z.boolean().optional(),
+            }),
+            execute: async (args, context) => {
+                try {
+                    const result = (await bff(context).rollbackLandingPage(args));
+                    return JSON.stringify({ ...result, nextSteps: hostedLandingNextSteps(result) });
+                }
+                catch (err) {
+                    return readError(err, missingKeyMessage);
+                }
+            },
+        });
+        add({
+            name: 'get_custom_domain',
+            description: "The project's custom domain: hostname, status (PENDING → VERIFIED → ACTIVE; FAILED; SUSPENDED when " +
+                'the TXT record disappeared), the exact DNS records to set, whether HTTPS for custom domains is ' +
+                'enabled on the platform (edgeConfigured) and the next step. Only ACTIVE is served. Requires project.read.',
+            parameters: z.object({ projectId: z.string().uuid() }),
+            execute: async (args, context) => {
+                try {
+                    return JSON.stringify(await bff(context).getCustomDomain(args));
+                }
+                catch (err) {
+                    return readError(err, missingKeyMessage);
+                }
+            },
+        });
+        add({
+            name: 'set_custom_domain',
+            description: 'Add a custom domain (www.example.com, or the apex) for the homepage and every hosted page of the ' +
+                'project (Pro; one hostname per project). Returns the exact DNS records: a CNAME to ' +
+                'hosted.extenshi.io (at an apex: CNAME flattening / ALIAS / ANAME, or use www) and a TXT ownership ' +
+                'token that stays in place (it is re-checked). Nothing is served until verify_custom_domain confirms the token and the ' +
+                'HTTPS certificate is issued; then the homepage is served at the domain root, its canonical and ' +
+                'HOMEPAGE_URL switch to it. Replacing the hostname starts over. Requires hosted.write.',
+            parameters: z.object({ projectId: z.string().uuid(), hostname: z.string().max(253) }),
+            execute: async (args, context) => {
+                try {
+                    return JSON.stringify(await bff(context).setCustomDomain(args));
+                }
+                catch (err) {
+                    return readError(err, missingKeyMessage);
+                }
+            },
+        });
+        add({
+            name: 'verify_custom_domain',
+            description: 'Check the custom domain now: looks up the TXT token, requests or refreshes the HTTPS certificate, ' +
+                'and moves the status (PENDING/FAILED → VERIFIED → ACTIVE). When it becomes ACTIVE the landing page ' +
+                'is republished with the new canonical and HOMEPAGE_URL moves to https://{hostname}/ (the ' +
+                'integration file in get_project_state follows). Safe to call repeatedly; DNS changes can take ' +
+                'minutes. The platform also re-checks every 6 hours. Requires hosted.write.',
+            parameters: z.object({ projectId: z.string().uuid() }),
+            execute: async (args, context) => {
+                try {
+                    return JSON.stringify(await bff(context).verifyCustomDomain(args));
+                }
+                catch (err) {
+                    return readError(err, missingKeyMessage);
+                }
+            },
+        });
+        add({
+            name: 'remove_custom_domain',
+            description: 'Remove the custom domain: it stops being served, the certificate is released, and the landing ' +
+                'canonical and HOMEPAGE_URL move back to page.extenshi.io/{code}. Remove the DNS records afterwards. ' +
+                'Requires hosted.write.',
+            parameters: z.object({ projectId: z.string().uuid() }),
+            execute: async (args, context) => {
+                try {
+                    return JSON.stringify(await bff(context).removeCustomDomain(args));
+                }
+                catch (err) {
+                    return readError(err, missingKeyMessage);
+                }
+            },
+        });
+        add({
+            name: 'get_install_instructions',
+            description: 'The hosted install instructions page of a project: {page: {publicCode, enabled, publishedAt, ' +
+                'input, url} or null, draft, draftProblems} — `draft` is the form saved by the install-instructions ' +
+                'tool in the cabinet; `draftProblems` lists why it cannot be published as it is. The page shows store and optional sideload steps for Chrome, Firefox and Edge in the ' +
+                'visitor’s browser language (en, es, pt-BR, fr, de, it, ru, ja, ko, zh-CN, ar), the visitor’s own ' +
+                'browser first. Free. Requires project.read.',
+            parameters: z.object({ projectId: z.string().uuid() }),
+            execute: async (args, context) => {
+                try {
+                    return JSON.stringify(await bff(context).getInstructionsPage(args));
+                }
+                catch (err) {
+                    return readError(err, missingKeyMessage);
+                }
+            },
+        });
+        add({
+            name: 'publish_install_instructions',
+            description: 'Publish (or update) the project’s install instructions at a stable public URL ' +
+                '(dojo.extenshi.io/instructions/<code>, or https://<custom domain>/instructions). Without `input` ' +
+                'the form saved in the cabinet is published (a saved form that does not validate is refused with ' +
+                'INSTRUCTIONS_INVALID and its field errors). Store URLs are the https listing links on ' +
+                'chromewebstore.google.com, addons.mozilla.org and microsoftedge.microsoft.com; browsers without one ' +
+                'are hidden unless none is set. The install steps are translated by Extenshi; `features` are ' +
+                'translated with set_page_translations (surface instructions). Returns {publicCode, url}. Free. ' +
+                'Requires hosted.write.',
+            parameters: z.object({
+                projectId: z.string().uuid(),
+                input: z
+                    .object({
+                    extensionName: z.string().max(120),
+                    storeUrls: z
+                        .object({
+                        chrome: z.string().max(2048).optional(),
+                        firefox: z.string().max(2048).optional(),
+                        edge: z.string().max(2048).optional(),
+                    })
+                        .optional(),
+                    features: z.array(z.string().max(200)).max(20).optional(),
+                    includeSideload: z.boolean().optional(),
+                    supportUrl: z.string().max(2048).optional().describe('https:// URL or an email address.'),
+                })
+                    .optional(),
+            }),
+            execute: async (args, context) => {
+                try {
+                    return JSON.stringify(await bff(context).publishInstructions(args));
+                }
+                catch (err) {
+                    return readError(err, missingKeyMessage);
+                }
+            },
+        });
+        add({
+            name: 'unpublish_install_instructions',
+            description: 'Take the hosted install instructions offline. The code and URL are kept, so publishing again ' +
+                'restores the same URL. Requires hosted.write.',
+            parameters: z.object({ projectId: z.string().uuid() }),
+            execute: async (args, context) => {
+                try {
+                    return JSON.stringify(await bff(context).setInstructionsEnabled({ projectId: args.projectId, enabled: false }));
+                }
+                catch (err) {
+                    return readError(err, missingKeyMessage);
+                }
+            },
+        });
+        add({
+            name: 'get_page_translations',
+            description: "The developer-written text on the project's hosted uninstall forms, welcome pages and install " +
+                'instructions (the features list), for ' +
+                'translation: per page {surface, publicCode, name, defaultLocale, locales, fields [{path, source, ' +
+                'label, max, multiline}], status per language [{locale, translated, missing, outdated}], ' +
+                'translations}. Languages are the project’s (manifest translations + the targetLocales decision); ' +
+                'the install instructions page offers every language its steps come in. ' +
+                'Built-in text (buttons, reasons, footers) is translated by Extenshi into en, es, pt-BR, fr, de, ' +
+                'it, ru, ja, ko, zh-CN and ar and is not listed. A page is shown in the user’s browser language ' +
+                'when the project offers it, otherwise in defaultLocale; an untranslated or outdated field shows ' +
+                'its original. Requires project.read.',
+            parameters: z.object({ projectId: z.string().uuid() }),
+            execute: async (args, context) => {
+                try {
+                    return JSON.stringify(await bff(context).getPageTranslations(args));
+                }
+                catch (err) {
+                    return readError(err, missingKeyMessage);
+                }
+            },
+        });
+        add({
+            name: 'set_page_translations',
+            description: 'Save one language of one uninstall form, welcome page or install instructions page: `translations` ' +
+                'maps field paths (from ' +
+                'get_page_translations) to translated text; the server records which original each translates, so ' +
+                'a later edit of the original marks it outdated. An empty string removes a translation. Unknown ' +
+                'paths, over-long text and the default language are refused (TRANSLATIONS_INVALID). Placeholders ' +
+                'and product names are kept as written. Returns the page’s updated translation status. Requires ' +
+                'hosted.write.',
+            parameters: z.object({
+                projectId: z.string().uuid(),
+                surface: z.enum(['uninstall', 'welcome', 'instructions']),
+                publicCode: z.string().max(40).describe('The page code, from get_page_translations.'),
+                locale: z.string().max(35).describe('BCP 47 tag or the _locales spelling (de, pt-BR, pt_BR).'),
+                translations: z.record(z.string().max(80), z.string().max(2000)),
+            }),
+            execute: async (args, context) => {
+                try {
+                    return JSON.stringify(await bff(context).setPageTranslations(args));
+                }
+                catch (err) {
+                    return readError(err, missingKeyMessage);
+                }
+            },
+        });
+        const legalDocument = z
+            .enum(['privacy_policy', 'license_terms'])
+            .describe('privacy_policy (hosted policy, Pro) or license_terms (Extenshi Pay license terms & refunds).');
+        add({
+            name: 'get_legal_translations',
+            description: "Translated copies of the project's published privacy policy or license terms. The English " +
+                'version is the binding text and stays at the base URL; each translation lives at ' +
+                '<url>/<locale>, says it is a translation for convenience and links to the English original. ' +
+                'Extenshi translates its own template text (en, es, pt-BR, fr, de, it, ru, ja, ko, zh-CN, ar); ' +
+                'what you translate is listed in fields: `section:<id>` for a section the author edited or added ' +
+                '(translate the whole section, heading line included) and `answer:<field>` for free-text answers ' +
+                'inside template sentences (e.g. a retention period). A section without a current translation is ' +
+                'shown in English. Returns {defaultLocale: "en", locales, fields, status per language, ' +
+                'translations, urls}. Languages are the project’s (manifest translations + targetLocales). ' +
+                'Requires a published document; privacy_policy needs project.read, license_terms pay.read.',
+            parameters: z.object({ projectId: z.string().uuid(), document: legalDocument }),
+            execute: async ({ projectId, document }, context) => {
+                try {
+                    const client = bff(context);
+                    return JSON.stringify(document === 'privacy_policy'
+                        ? await client.getPrivacyPolicyTranslations({ projectId })
+                        : await client.getLicenseTermsTranslations({ projectId }));
+                }
+                catch (err) {
+                    return readError(err, missingKeyMessage);
+                }
+            },
+        });
+        add({
+            name: 'set_legal_translations',
+            description: 'Save one language of the privacy policy or license terms translation: `translations` maps field ' +
+                'paths from get_legal_translations to text. A `section:<id>` text is accepted as exactly one ' +
+                'section: its "## " heading line first ("# " for `section:lead`) and no other heading. ' +
+                'The server records which English text each translates, so a later edit marks it outdated; an ' +
+                'empty string removes one. Only the project’s languages are accepted (TRANSLATIONS_INVALID ' +
+                'otherwise). Nothing changes in the English original. privacy_policy needs hosted.write and a ' +
+                'Pro project; license_terms needs pay.write.',
+            parameters: z.object({
+                projectId: z.string().uuid(),
+                document: legalDocument,
+                locale: z.string().max(35).describe('BCP 47 tag or the _locales spelling (de, pt-BR, pt_BR).'),
+                translations: z.record(z.string().max(300), z.string().max(16000)),
+                sources: z
+                    .record(z.string().max(300), z.string().max(64000))
+                    .optional()
+                    .describe('The `source` of each field as get_legal_translations returned it; a save whose English has changed since is refused (TRANSLATIONS_STALE).'),
+            }),
+            execute: async ({ document, ...args }, context) => {
+                try {
+                    const client = bff(context);
+                    return JSON.stringify(document === 'privacy_policy'
+                        ? await client.setPrivacyPolicyTranslations(args)
+                        : await client.setLicenseTermsTranslations(args));
+                }
+                catch (err) {
+                    return readError(err, missingKeyMessage);
+                }
+            },
+        });
         // A local filesystem exists only where local artifacts do (stdio).
         const localFiles = caps.has('scan');
         add({
@@ -1825,7 +2377,9 @@ export function registerTools(server, deps) {
                 'as an image, or an image URL), screenshots and the canonical homepage URL for Open Graph and ' +
                 'JSON-LD. Returns JSON {html, bytes, warnings, nextSteps}: warnings list input that was dropped ' +
                 'or clamped; nextSteps cover hosting the file on HTTPS and registering the URL with ' +
-                'upsert_hosted_page, which feeds HOMEPAGE_URL. Extenshi does not host the page. Static content: ' +
+                'upsert_hosted_page, which feeds HOMEPAGE_URL. Extenshi does not host the page. With schemaVersion 2 ' +
+                'the page is built from sections, theme tokens, SEO and locales (see the field descriptions); the ' +
+                'result adds problems [{path, severity, message, fix}] and localePages. Static content: ' +
                 'no API key, no network, no credits.',
             parameters: z.object(LANDING_FORM_SHAPE),
             execute: async (args) => JSON.stringify(renderGenerateLandingPage(args)),