@materializecms/server 0.8.0 → 0.9.0

package/src/remote.js

@@ -1,70 +1,235 @@
-import { lookup } from 'node:dns/promises';
+import { lookup as dnsLookup } from 'node:dns';
+import { request as httpRequest } from 'node:http';
+import { request as httpsRequest } from 'node:https';
 import { isIP } from 'node:net';
-/** Raised when a remote file cannot be fetched: the message says why, in words. */
+import { createBrotliDecompress, createGunzip, createInflate } from 'node:zlib';
+import { t } from './t.js';
+/**
+ * Raised when a remote file cannot be fetched: the message says why, in words (in the reader's
+ * language); `reason` says it to code.
+ */
 export class RemoteError extends Error {
+    reason;
+    constructor(message, reason) {
+        super(message);
+        this.reason = reason;
+    }
+}
+/** The four numbers of an IPv4 address written the usual way, or null. */
+function ipv4Parts(address) {
+    const parts = address.split('.');
+    if (parts.length !== 4 || parts.some((p) => !/^\d{1,3}$/.test(p) || Number(p) > 255))
+        return null;
+    return parts.map(Number);
+}
+/** Loopback, private, shared, link-local, test and multicast IPv4 ranges: no public file lives there. */
+function privateV4([a = 0, b = 0, c = 0]) {
+    return (a === 0 ||
+        a === 10 ||
+        a === 127 ||
+        (a === 100 && b >= 64 && b <= 127) ||
+        (a === 169 && b === 254) ||
+        (a === 172 && b >= 16 && b <= 31) ||
+        (a === 192 && b === 0 && (c === 0 || c === 2)) ||
+        (a === 192 && b === 168) ||
+        (a === 198 && (b === 18 || b === 19)) ||
+        (a === 198 && b === 51 && c === 100) ||
+        (a === 203 && b === 0 && c === 113) ||
+        a >= 224);
+}
+/**
+ * The eight 16-bit groups of an IPv6 address, with "::" filled in and a dotted IPv4 tail
+ * (::ffff:1.2.3.4) turned into its two groups; null when it is not one.
+ */
+function ipv6Groups(address) {
+    let a = address.toLowerCase().replace(/^\[|\]$/g, '');
+    const zone = a.indexOf('%');
+    if (zone >= 0)
+        a = a.slice(0, zone);
+    if (a.includes('.')) {
+        const at = a.lastIndexOf(':');
+        const v4 = ipv4Parts(a.slice(at + 1));
+        if (!v4)
+            return null;
+        a = `${a.slice(0, at + 1)}${(((v4[0] ?? 0) << 8) | (v4[1] ?? 0)).toString(16)}:${(((v4[2] ?? 0) << 8) | (v4[3] ?? 0)).toString(16)}`;
+    }
+    const halves = a.split('::');
+    if (halves.length > 2)
+        return null;
+    const read = (s) => (s ? s.split(':') : []);
+    const head = read(halves[0] ?? '');
+    const tail = read(halves[1] ?? '');
+    const missing = 8 - head.length - tail.length;
+    if (halves.length === 1 ? missing !== 0 : missing < 1)
+        return null;
+    const groups = [...head, ...Array(halves.length === 2 ? missing : 0).fill('0'), ...tail];
+    if (groups.some((g) => !/^[0-9a-f]{1,4}$/.test(g)))
+        return null;
+    return groups.map((g) => Number.parseInt(g, 16));
+}
+/** The IPv4 address carried in two IPv6 groups. */
+const v4Of = (hi, lo) => [hi >> 8, hi & 0xff, lo >> 8, lo & 0xff];
+/**
+ * Loopback, private, link-local and other addresses a public file never lives at. IPv6 is read
+ * group by group, so the same IPv4 address cannot slip through written another way (mapped as
+ * ::ffff:7f00:1, compatible, NAT64, 6to4). Anything that is not an address counts as private.
+ */
+export function isPrivate(address) {
+    const v4 = ipv4Parts(address);
+    if (v4)
+        return privateV4(v4);
+    const g = ipv6Groups(address);
+    if (!g)
+        return true;
+    const [g0 = 0, g1 = 0, g2 = 0, g3 = 0, g4 = 0, g5 = 0, g6 = 0, g7 = 0] = g;
+    const zeros = (...xs) => xs.every((x) => x === 0);
+    // ::, ::1 and the old IPv4-compatible ::a.b.c.d, which no public server uses.
+    if (zeros(g0, g1, g2, g3, g4, g5))
+        return true;
+    // IPv4 inside (::ffff:a.b.c.d, ::ffff:0:a.b.c.d): judged as that IPv4.
+    if (zeros(g0, g1, g2, g3, g4) && g5 === 0xffff)
+        return privateV4(v4Of(g6, g7));
+    if (zeros(g0, g1, g2, g3) && g4 === 0xffff && g5 === 0)
+        return privateV4(v4Of(g6, g7));
+    // NAT64 (64:ff9b::/96 carries an IPv4; 64:ff9b:1::/48 is for local networks).
+    if (g0 === 0x64 && g1 === 0xff9b)
+        return g2 === 1 || !zeros(g2, g3, g4, g5) || privateV4(v4Of(g6, g7));
+    // 6to4: the IPv4 sits in the second and third groups.
+    if (g0 === 0x2002)
+        return privateV4(v4Of(g1, g2));
+    // Teredo (its IPv4 is scrambled) and the documentation range: never a real public file.
+    if (g0 === 0x2001 && (g1 === 0 || g1 === 0xdb8))
+        return true;
+    // Discard-only (100::/64).
+    if (g0 === 0x100 && zeros(g1, g2, g3))
+        return true;
+    return ((g0 & 0xfe00) === 0xfc00 || // unique local
+        (g0 & 0xffc0) === 0xfe80 || // link-local
+        (g0 & 0xffc0) === 0xfec0 || // site-local (old)
+        (g0 & 0xff00) === 0xff00 // multicast
+    );
 }
-/** Loopback, private, link-local and other addresses a public file never lives at. */
-function isPrivate(address) {
-    if (isIP(address) === 6) {
-        const a = address.toLowerCase();
-        if (a.startsWith('::ffff:'))
-            return isPrivate(a.slice(7));
-        return a === '::1' || a === '::' || a.startsWith('fc') || a.startsWith('fd') || a.startsWith('fe80');
+/**
+ * Resolves a name and refuses it when any of its addresses is private: run by the connection
+ * itself, so the address checked is the one connected to (a name cannot answer with a public
+ * address to the check and a private one a moment later).
+ */
+const publicLookup = (hostname, options, callback) => {
+    dnsLookup(hostname, { ...options, all: true }, (error, found) => {
+        if (error)
+            return callback(error, '', 0);
+        if (!found.length || found.some((a) => isPrivate(a.address)))
+            return callback(new RemoteError(t('Questo indirizzo non è pubblico'), 'private'), '', 0);
+        if (options.all)
+            return callback(null, found);
+        const first = found[0];
+        callback(null, first.address, first.family);
+    });
+};
+/** Turns Node's response headers into the Headers callers read. */
+function headersOf(res) {
+    const out = new Headers();
+    for (const [k, v] of Object.entries(res.headers)) {
+        if (v === undefined)
+            continue;
+        for (const one of Array.isArray(v) ? v : [v])
+            out.append(k, one);
     }
-    const [x = 0, y = 0] = address.split('.').map(Number);
-    return (x === 10 ||
-        x === 127 ||
-        x === 0 ||
-        (x === 169 && y === 254) ||
-        (x === 172 && y >= 16 && y <= 31) ||
-        (x === 192 && y === 168) ||
-        (x === 100 && y >= 64 && y <= 127) ||
-        x >= 224);
+    return out;
+}
+/** One request, one answer: no redirects followed here. */
+function send(url, options, headers) {
+    return new Promise((resolve, reject) => {
+        const req = (url.protocol === 'https:' ? httpsRequest : httpRequest)(url, {
+            method: options.method ?? 'GET',
+            headers: {
+                ...headers,
+                ...(options.body !== undefined ? { 'content-length': String(Buffer.byteLength(options.body)) } : {}),
+            },
+            ...(options.allowPrivate ? {} : { lookup: publicLookup }),
+            signal: AbortSignal.timeout(options.timeout ?? 15_000),
+        });
+        req.on('response', resolve);
+        req.on('error', reject);
+        req.end(options.body);
+    });
+}
+/** The body as sent, uncompressed when the server compressed it anyway. */
+function decoded(res) {
+    const encoding = (res.headers['content-encoding'] ?? '').toLowerCase().trim();
+    if (encoding === 'gzip' || encoding === 'x-gzip')
+        return res.pipe(createGunzip());
+    if (encoding === 'deflate')
+        return res.pipe(createInflate());
+    if (encoding === 'br')
+        return res.pipe(createBrotliDecompress());
+    return res;
 }
 /**
  * Fetches from the web: http(s) only, redirects checked one by one, at most `max` bytes. Addresses
  * on this machine or its network are refused, unless `allowPrivate` (an administrator importing
- * from a WordPress on their own network). Headers are sent to the first host only.
+ * from a WordPress on their own network), and checked when connecting, not before. Headers are
+ * sent to the first host only.
  */
 export async function remoteFetch(url, options) {
     let current = new URL(url);
     const origin = current.origin;
-    for (let hop = 0; hop < 5; hop++) {
+    const hops = (options.maxRedirects ?? 4) + 1;
+    for (let hop = 0; hop < hops; hop++) {
         if (current.protocol !== 'https:' && current.protocol !== 'http:')
-            throw new RemoteError('Only http and https addresses');
-        if (!options.allowPrivate) {
-            const host = current.hostname.replace(/^\[|\]$/g, '');
-            const addresses = isIP(host) ? [host] : (await lookup(host, { all: true })).map((a) => a.address);
-            if (!addresses.length || addresses.some(isPrivate))
-                throw new RemoteError('This address is not public');
+            throw new RemoteError(t('Solo indirizzi http e https'));
+        // An address written as numbers never goes through the lookup: it is checked here.
+        const host = current.hostname.replace(/^\[|\]$/g, '');
+        if (!options.allowPrivate && isIP(host) && isPrivate(host))
+            throw new RemoteError(t('Questo indirizzo non è pubblico'), 'private');
+        let res;
+        try {
+            res = await send(current, options, current.origin === origin ? options.headers : undefined);
         }
-        const res = await fetch(current, {
-            redirect: 'manual',
-            headers: current.origin === origin ? options.headers : undefined,
-            signal: AbortSignal.timeout(options.timeout ?? 15_000),
-        });
-        if (res.status >= 300 && res.status < 400) {
-            const to = res.headers.get('location');
+        catch (error) {
+            // The refusal from the lookup may come back wrapped by the connection: said the same way.
+            if (error instanceof RemoteError)
+                throw error;
+            if (error.cause instanceof RemoteError)
+                throw error.cause;
+            throw error;
+        }
+        const status = res.statusCode ?? 0;
+        if (status >= 300 && status < 400) {
+            res.resume();
+            const to = res.headers.location;
             if (!to)
-                throw new RemoteError(`Redirect without a destination (${res.status})`);
+                throw new RemoteError(t('Reindirizzamento senza destinazione ({status})', { status }));
             current = new URL(to, current);
             continue;
         }
-        const type = (res.headers.get('content-type') ?? '').split(';')[0]?.trim() ?? '';
-        if (Number(res.headers.get('content-length') ?? 0) > options.max)
-            throw new RemoteError('The file is too large');
+        const type = (res.headers['content-type'] ?? '').split(';')[0]?.trim() ?? '';
+        if (Number(res.headers['content-length'] ?? 0) > options.max) {
+            res.destroy();
+            throw new RemoteError(t('Il file è troppo grande'), 'too_large');
+        }
         const chunks = [];
         let size = 0;
-        for await (const chunk of res.body ?? []) {
-            size += chunk.length;
-            if (size > options.max)
-                throw new RemoteError('The file is too large');
-            chunks.push(Buffer.from(chunk));
+        const stream = decoded(res);
+        try {
+            for await (const chunk of stream) {
+                size += chunk.length;
+                // Counted after decompressing: a small compressed answer cannot fill the memory.
+                if (size > options.max)
+                    throw new RemoteError(t('Il file è troppo grande'), 'too_large');
+                chunks.push(chunk);
+            }
+        }
+        finally {
+            if (size > options.max) {
+                stream.destroy();
+                res.destroy();
+            }
         }
         const name = decodeURIComponent(current.pathname.split('/').pop() || 'immagine');
-        return { status: res.status, headers: res.headers, bytes: Buffer.concat(chunks), type, name, url: current.href };
+        return { status, headers: headersOf(res), bytes: Buffer.concat(chunks), type, name, url: current.href };
     }
-    throw new RemoteError('Too many redirects');
+    throw new RemoteError(t('Troppi reindirizzamenti'));
 }
 /**
  * Downloads a public file (an image an AI found on the web): http(s) only, never to an address on
@@ -73,6 +238,6 @@ export async function remoteFetch(url, options) {
 export async function fetchPublicFile(url, max) {
     const res = await remoteFetch(url, { max });
     if (res.status < 200 || res.status >= 300)
-        throw new RemoteError(`The server answered ${res.status}`);
+        throw new RemoteError(t('Il server ha risposto {status}', { status: res.status }));
     return { bytes: res.bytes, type: res.type, name: res.name };
 }

package/src/status-page.js

@@ -1,9 +1,11 @@
+import { currentLang } from '@materializecms/core/lang';
 import { html } from 'hono/html';
+import { t } from './t.js';
 /** Page served at "/" until the site renderer ships: confirms the server works and links to the admin. */
 export function statusPage(config, version, needsSetup) {
     const rows = config.collections.map((c) => html `<li><span>${c.label}</span><code>/api/content/${c.name}</code></li>`);
     return html `<!doctype html>
-    <html lang="it">
+    <html lang="${currentLang()}">
       <head>
         <meta charset="utf-8" />
         <meta name="viewport" content="width=device-width, initial-scale=1" />
@@ -27,12 +29,15 @@ export function statusPage(config, version, needsSetup) {
       <body>
         <main>
           <div class="mark" aria-hidden="true">M</div>
-          <h1>${config.site.name} è online</h1>
-          <p>Materialize ${version} · ${config.collections.length} collezioni · lingue: ${config.locales.available.join(', ')}</p>
+          <h1>${t('{site} è online', { site: config.site.name })}</h1>
+          <p>
+            Materialize ${version} · ${t.n(config.collections.length, '{n} collezione', '{n} collezioni')} ·
+            ${t('lingue: {list}', { list: config.locales.available.join(', ') })}
+          </p>
           <ul>
             ${rows}
           </ul>
-          <a class="button" href="/admin/">${needsSetup ? 'Configura il pannello' : 'Apri il pannello'}</a>
+          <a class="button" href="/admin/">${needsSetup ? t('Configura il pannello') : t('Apri il pannello')}</a>
         </main>
       </body>
     </html>`;

package/src/t.d.ts

@@ -0,0 +1,2 @@
+/** Texts of this package in the language of whoever reads them (see core/src/lang.ts). */
+export declare const t: import("@materializecms/core/lang").Translate;

package/src/t.js

@@ -0,0 +1,4 @@
+import { translator } from '@materializecms/core/lang';
+import { en } from './en/index.js';
+/** Texts of this package in the language of whoever reads them (see core/src/lang.ts). */
+export const t = translator(en);

package/src/tools.js

@@ -1,7 +1,8 @@
-import { buildSection, LIBRARY } from '@materializecms/core/library';
+import { buildSection, library } from '@materializecms/core/library';
 import { cloneNode, collapseComponents, collapseGlobals, expandComponents, expandGlobals, findNode, insertNode, newId, plainText, removeNode, updateNode, } from '@materializecms/core/page';
 import { voicePrompt } from '@materializecms/core/voice';
 import { z } from 'zod';
+import { t } from './t.js';
 /** An answer the model can act on: what went wrong, in words. */
 export class ToolError extends Error {
 }
@@ -101,7 +102,7 @@ export function applyOperations(nodes, ops, brand) {
         const need = (id) => findNode(tree, id) ?? fail(`there is no node "${id}"`);
         switch (op.op) {
             case 'add_section': {
-                if (!LIBRARY.some((c) => c.variants.some((v) => v.key === op.key)))
+                if (!library().some((c) => c.variants.some((v) => v.key === op.key)))
                     fail(`no library section "${op.key}"`);
                 tree = insertNode(tree, null, op.index ?? tree.length, buildSection(op.key, brand));
                 break;
@@ -171,7 +172,7 @@ export function pageTools(options) {
     return [
         tool({
             name: 'get_page',
-            title: 'Leggo la pagina',
+            title: t('Leggo la pagina'),
             description: 'The page as an outline: one line per node with its id, type, name and text. Read it before editing, and again after big changes.',
             input: z.object({ ...id }),
             readOnly: true,
@@ -179,7 +180,7 @@ export function pageTools(options) {
         }),
         tool({
             name: 'get_node',
-            title: 'Leggo un elemento',
+            title: t('Leggo un elemento'),
             description: 'One node with all its properties and children, as JSON: to see its exact design before changing it.',
             input: z.object({ ...id, nodeId: z.string() }),
             readOnly: true,
@@ -192,7 +193,7 @@ export function pageTools(options) {
         }),
         tool({
             name: 'edit_page',
-            title: 'Modifico la pagina',
+            title: t('Modifico la pagina'),
             description: `Changes the page with a list of operations, applied in order and saved together (all or nothing): add_section from the library, insert a node, update properties, replace, remove, move, duplicate. Returns the new outline.\n\n${PAGE_GUIDE}`,
             input: z.object({ ...id, operations: z.array(operation).min(1).max(60) }),
             run: async (input) => {
@@ -274,7 +275,7 @@ export function contentTools(call, getSchema) {
     return [
         tool({
             name: 'get_site',
-            title: 'Guardo il sito',
+            title: t('Guardo il sito'),
             description: 'The site: its name, languages, collections (pages, articles, projects…) with their fields, and its brand voice: follow it in every text you write. Start here.',
             input: z.object({}),
             readOnly: true,
@@ -296,7 +297,7 @@ export function contentTools(call, getSchema) {
         }),
         tool({
             name: 'list_entries',
-            title: 'Elenco i contenuti',
+            title: t('Elenco i contenuti'),
             description: 'Entries of a collection (newest changes first), with id, title, address and whether published.',
             input: z.object({
                 collection: z.string(),
@@ -316,7 +317,7 @@ export function contentTools(call, getSchema) {
         }),
         tool({
             name: 'get_entry',
-            title: 'Leggo un contenuto',
+            title: t('Leggo un contenuto'),
             description: 'An entry with all its fields. For pages built on the canvas the page field is long: use get_page to read it as an outline.',
             input: z.object({ id: z.string() }),
             readOnly: true,
@@ -333,7 +334,7 @@ export function contentTools(call, getSchema) {
         }),
         tool({
             name: 'create_entry',
-            title: 'Creo un contenuto',
+            title: t('Creo un contenuto'),
             description: 'A new draft in a collection, with the fields given (see get_site for their names). The address (slug) follows the title when left out. Publish it with publish_entry.',
             input: z.object({
                 collection: z.string(),
@@ -347,7 +348,7 @@ export function contentTools(call, getSchema) {
         }),
         tool({
             name: 'update_entry',
-            title: 'Modifico un contenuto',
+            title: t('Modifico un contenuto'),
             description: 'Changes some fields of an entry (the others stay as they are) and saves the draft. Use edit_page for the design of a page.',
             input: z.object({ id: z.string(), data: z.record(z.string(), z.unknown()) }),
             run: async (input) => {
@@ -360,7 +361,7 @@ export function contentTools(call, getSchema) {
         }),
         tool({
             name: 'publish_entry',
-            title: 'Pubblico',
+            title: t('Pubblico'),
             description: 'Puts the current draft of an entry on the public site.',
             input: z.object({ id: z.string() }),
             run: async (input) => {
@@ -370,7 +371,7 @@ export function contentTools(call, getSchema) {
         }),
         tool({
             name: 'unpublish_entry',
-            title: 'Tolgo dal sito',
+            title: t('Tolgo dal sito'),
             description: 'Takes an entry off the public site; it stays as a draft.',
             input: z.object({ id: z.string() }),
             run: async (input) => {
@@ -380,7 +381,7 @@ export function contentTools(call, getSchema) {
         }),
         tool({
             name: 'schedule_entry',
-            title: 'Programmo',
+            title: t('Programmo'),
             description: 'Sets when an entry goes on the public site (publish) or comes off it (unpublish) by itself, as an ISO date with time zone, e.g. 2026-11-10T09:00:00+01:00. at null cancels. The draft as it is at that moment is what gets published.',
             input: z.object({
                 id: z.string(),
@@ -399,7 +400,7 @@ export function contentTools(call, getSchema) {
         }),
         tool({
             name: 'share_preview',
-            title: 'Creo un link di anteprima',
+            title: t('Creo un link di anteprima'),
             description: 'A secret link that shows an entry’s latest saved draft with the site’s design to someone without an account (a client, a colleague). It follows later edits. days: how long it works (default 7), null until revoked.',
             input: z.object({
                 id: z.string(),
@@ -412,7 +413,7 @@ export function contentTools(call, getSchema) {
         }),
         tool({
             name: 'list_releases',
-            title: 'Guardo i rilasci',
+            title: t('Guardo i rilasci'),
             description: 'Releases: groups of entries that go on (or off) the site together, all or nothing, by hand or at a set time. Each with its entries, whether it is ready and what stops it.',
             input: z.object({}),
             readOnly: true,
@@ -420,14 +421,14 @@ export function contentTools(call, getSchema) {
         }),
         tool({
             name: 'create_release',
-            title: 'Creo un rilascio',
+            title: t('Creo un rilascio'),
             description: 'A new, empty release with a name (e.g. "Collezione inverno"). Add entries with add_to_release.',
             input: z.object({ name: z.string().min(1).max(120) }),
             run: (input) => call('POST', '/api/releases', input),
         }),
         tool({
             name: 'add_to_release',
-            title: 'Aggiungo al rilascio',
+            title: t('Aggiungo al rilascio'),
             description: 'Puts an entry in a release: its draft is published when the release goes out (action "publish"), or it is taken off the site (action "unpublish"). An entry is in one release at a time. remove: true takes it out of the release.',
             input: z.object({
                 release: z.string().describe('The release id'),
@@ -443,21 +444,21 @@ export function contentTools(call, getSchema) {
         }),
         tool({
             name: 'publish_release',
-            title: 'Pubblico il rilascio',
+            title: t('Pubblico il rilascio'),
             description: 'Puts everything in a release on the public site now. All entries must be ready, or nothing goes out and the reasons come back.',
             input: z.object({ release: z.string() }),
             run: (input) => call('POST', `/api/releases/${encodeURIComponent(input.release)}/publish`),
         }),
         tool({
             name: 'schedule_release',
-            title: 'Programmo il rilascio',
+            title: t('Programmo il rilascio'),
             description: 'Sets when a release goes out by itself, as an ISO date with time zone, e.g. 2026-11-10T09:00:00+01:00; at null: only by hand. The drafts as they are at that moment go out.',
             input: z.object({ release: z.string(), at: z.string().nullable() }),
             run: (input) => call('PUT', `/api/releases/${encodeURIComponent(input.release)}/schedule`, { at: input.at }),
         }),
         tool({
             name: 'list_translations',
-            title: 'Guardo le lingue',
+            title: t('Guardo le lingue'),
             description: 'The language versions of an entry (its original and translations, with id and status) and the site languages it is still missing.',
             input: z.object({ id: z.string() }),
             readOnly: true,
@@ -465,7 +466,7 @@ export function contentTools(call, getSchema) {
         }),
         tool({
             name: 'translate_entry',
-            title: 'Traduco',
+            title: t('Traduco'),
             description: 'Creates the version of an entry in another site language, as a draft linked to the original. With translate: true the site AI translates every text (and the address); otherwise it is a copy to translate, e.g. with update_entry or edit_page. Menus and footers shared by pages are translated once per language in the editor.',
             input: z.object({
                 id: z.string(),
@@ -482,15 +483,15 @@ export function contentTools(call, getSchema) {
         }),
         tool({
             name: 'list_library',
-            title: 'Guardo la libreria di sezioni',
+            title: t('Guardo la libreria di sezioni'),
             description: 'Ready-made sections that can be added to a page (edit_page → add_section), by category.',
             input: z.object({}),
             readOnly: true,
-            run: async () => LIBRARY.map((c) => ({ category: c.label, sections: c.variants.map((v) => `${v.key} (${v.label})`) })),
+            run: async () => library().map((c) => ({ category: c.label, sections: c.variants.map((v) => `${v.key} (${v.label})`) })),
         }),
         tool({
             name: 'get_theme',
-            title: 'Leggo il tema',
+            title: t('Leggo il tema'),
             description: 'The design theme: colors (light and dark), fonts, roundness, text styles.',
             input: z.object({}),
             readOnly: true,
@@ -498,7 +499,7 @@ export function contentTools(call, getSchema) {
         }),
         tool({
             name: 'update_theme',
-            title: 'Modifico il tema',
+            title: t('Modifico il tema'),
             description: 'Changes the theme: give only what changes, e.g. {"display": "Fraunces", "colors": {"light": {"accent": "#e94f37"}}}. Fonts are Google Fonts names. Applies to the whole site at once.',
             input: z.object({ patch: z.record(z.string(), z.unknown()) }),
             run: async (input) => {
@@ -508,7 +509,7 @@ export function contentTools(call, getSchema) {
         }),
         tool({
             name: 'list_media',
-            title: 'Guardo la libreria media',
+            title: t('Guardo la libreria media'),
             description: 'Images and files already uploaded, with their address (src) to use in pages and fields.',
             input: z.object({ search: z.string().optional(), limit: z.number().int().min(1).max(100).optional() }),
             readOnly: true,
@@ -521,7 +522,7 @@ export function contentTools(call, getSchema) {
         }),
         tool({
             name: 'upload_media_from_url',
-            title: 'Aggiungo un’immagine dal web',
+            title: t('Aggiungo un’immagine dal web'),
             description: 'Downloads an image from a public https address into the media library and returns its src. Only use images the site may publish.',
             input: z.object({ url: z.url(), alt: z.string().max(500).optional() }),
             run: async (input) => call('POST', '/api/media/from-url', input),

package/src/wordpress.js

@@ -1,5 +1,6 @@
 import { newId } from '@materializecms/core/page';
 import { DomUtils, parseDocument } from 'htmlparser2';
+import { t } from './t.js';
 export class WordPressError extends Error {
 }
 const parse = (html, xml = false) => parseDocument(html, xml ? { xmlMode: true } : { decodeEntities: true });
@@ -40,7 +41,7 @@ export async function readRest(base, fetcher, options = {}) {
         }
     }
     if (!api)
-        throw new WordPressError('Non trovo l’API di WordPress a questo indirizzo: controlla che sia il sito giusto, oppure usa il file di esportazione.');
+        throw new WordPressError(t('Non trovo l’API di WordPress a questo indirizzo: controlla che sia il sito giusto, oppure usa il file di esportazione.'));
     const endpoint = api;
     const items = [];
     for (const kind of ['post', 'page']) {
@@ -56,9 +57,9 @@ export async function readRest(base, fetcher, options = {}) {
             if (res.status === 400 && page > 1)
                 break;
             if (res.status === 401 || res.status === 403)
-                throw new WordPressError('WordPress non dà accesso ai contenuti: controlla utente e password applicativa.');
+                throw new WordPressError(t('WordPress non dà accesso ai contenuti: controlla utente e password applicativa.'));
             if (res.status !== 200)
-                throw new WordPressError(`WordPress ha risposto ${res.status} leggendo ${route}`);
+                throw new WordPressError(t('WordPress ha risposto {status} leggendo {route}', { status: res.status, route }));
             const list = JSON.parse(res.text);
             for (const p of list)
                 items.push(fromRest(p, kind));
@@ -118,7 +119,7 @@ export function readWxr(xml) {
     };
     const channel = find(doc, 'channel');
     if (!channel || !find(channel, 'wp:wxr_version'))
-        throw new WordPressError('Questo non è un file di esportazione di WordPress (Strumenti → Esporta).');
+        throw new WordPressError(t('Questo non è un file di esportazione di WordPress (Strumenti → Esporta).'));
     const child = (node, name) => (node.children ?? []).find((c) => c.name === name);
     const text = (node) => (node ? textOf(node).trim() : '');
     const rawItems = (channel.children ?? []).filter((c) => c.name === 'item');
@@ -499,7 +500,7 @@ export function htmlToPage(html, title, ctx) {
     const sections = [];
     let current = null;
     const section = () => {
-        current = { id: newId(), type: 'frame', name: 'Sezione', layout: 'col', gap: 20, size: 'm', children: [] };
+        current = { id: newId(), type: 'frame', name: t('Sezione'), layout: 'col', gap: 20, size: 'm', children: [] };
         sections.push(current);
         return current;
     };
@@ -527,7 +528,7 @@ export function htmlToPage(html, title, ctx) {
                 add({
                     id: newId(),
                     type: 'image',
-                    name: 'Immagine',
+                    name: t('Immagine'),
                     src: img.src,
                     alt: p.alt || img.alt,
                     ratio: img.width && img.height ? `${img.width}/${img.height}` : '16/9',
@@ -540,7 +541,7 @@ export function htmlToPage(html, title, ctx) {
             add({
                 id: newId(),
                 type: 'button',
-                name: 'Pulsante',
+                name: t('Pulsante'),
                 text: p.text,
                 href: p.href,
                 variant: 'primary',
@@ -568,12 +569,12 @@ export function htmlToPage(html, title, ctx) {
                 ? p.runs.map((r) => ({ ...r, i: true }))
                 : p.runs;
         add(text(runs, style, p.style === 'li'
-            ? 'Punto elenco'
+            ? t('Punto elenco')
             : p.style.startsWith('h')
-                ? 'Titolo'
+                ? t('Titolo')
                 : p.style === 'quote'
-                    ? 'Citazione'
-                    : 'Testo'));
+                    ? t('Citazione')
+                    : t('Testo')));
     }
     return sections;
 }