@materializecms/cli 0.0.0-stage → 0.2.0

package/src/commands.js

@@ -0,0 +1,425 @@
+import { randomBytes } from 'node:crypto';
+import { watch } from 'node:fs';
+import { copyFile, mkdir, open, readFile, rm, writeFile } from 'node:fs/promises';
+import { dirname, join, relative, resolve } from 'node:path';
+import { styleText } from 'node:util';
+import { resolveRedirect } from '@materializecms/core/seo';
+import { createActivityStore, createAuthStore, createContentStore, createSettingsStore, openDatabase, } from '@materializecms/db';
+import { apiCaller, createFonts, createMcpServer, createMediaFiles, extractTarGz, restoreMedia, startServer, VERSION, } from '@materializecms/server';
+import { findConfig, loadConfig } from './load-config.js';
+import { buildSite, exportFonts, exportMedia, hasSite, ProductionSite, startDevSite } from './site.js';
+import { RESTART } from './supervisor.js';
+import { createUpdates } from './updates.js';
+const dim = (s) => styleText('dim', s);
+const accent = (s) => styleText(['bold', 'blue'], s);
+const ok = (s) => styleText('green', s);
+const fail = (s) => styleText('red', s);
+const HELP = `
+${accent('materialize')} ${dim(VERSION)}
+
+  materialize dev      Avvia CMS e sito, ricarica lo schema a ogni salvataggio
+  materialize build    Genera il sito statico in dist/client, immagini comprese
+  materialize start    Avvia CMS e sito in produzione (il sito si rigenera a ogni pubblicazione);
+                       un supervisore lo tiene acceso e applica gli aggiornamenti dal pannello
+  materialize mcp      Server MCP su stdio per i client AI locali (serve il CMS avviato)
+  materialize restore <file>
+                       Rimette un backup (content-….db, o l'archivio completo materialize-….tar.gz);
+                       il server va fermato
+  materialize reset-password <email>
+                       Un link per una nuova password, valido un'ora: per chi non può riceverlo per email
+                       (per esempio l'unico amministratore, senza email configurata)
+  materialize --help   Mostra questo aiuto
+
+Opzioni
+  --port <numero>      Porta del server (predefinita: quella del config, 4321)
+  --host <indirizzo>   Indirizzo su cui ascoltare (predefinito: tutti; 127.0.0.1 dietro un proxy)
+  --url <indirizzo>    Con mcp: il CMS a cui collegarsi (predefinito: http://localhost:<porta>)
+  --no-supervisor      Con start: senza supervisore (se il server lo tiene acceso un altro programma)
+
+Il server MCP usa un token personale (Impostazioni → AI e MCP) in MATERIALIZE_TOKEN.
+`;
+/** Kept until the installation is done, so a restart (or the VPS installer, which reads it) keeps the same link. */
+const INSTALL_CODE = '.materialize/install-code';
+async function installCode(site) {
+    const path = join(site, INSTALL_CODE);
+    const kept = await readFile(path, 'utf8').catch(() => '');
+    if (/^[\w-]{12,}$/.test(kept.trim()))
+        return kept.trim();
+    const code = randomBytes(9).toString('base64url');
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, code, { mode: 0o600 });
+    return code;
+}
+function summary(config) {
+    return config.collections.map((c) => c.name).join(', ');
+}
+function describeError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function run(mode, args) {
+    const cwd = process.cwd();
+    const path = findConfig(cwd);
+    if (!path) {
+        console.error(fail('Non trovo materialize.config.ts in questa cartella.'));
+        console.error(dim('Crea un nuovo progetto con: npm create materialize@latest'));
+        process.exit(1);
+    }
+    let config;
+    try {
+        config = await loadConfig(path);
+    }
+    catch (error) {
+        console.error(fail(describeError(error)));
+        process.exit(1);
+    }
+    const withSite = hasSite(cwd);
+    if (mode === 'build') {
+        if (!withSite) {
+            console.error(fail('Non c’è un sito da generare: manca astro.config.ts in questa cartella.'));
+            process.exit(1);
+        }
+        const started = performance.now();
+        await buildSite(cwd, `${cwd}/dist`);
+        const images = await exportMedia(`${cwd}/dist/client`, createMediaFiles(config.media.dir));
+        await exportFonts(`${cwd}/dist/client`, createFonts(join(dirname(resolve(config.media.dir)), 'fonts')));
+        const elapsed = Math.round(performance.now() - started);
+        console.log(`  ${ok('✓')} Sito generato in dist/client ${dim(`(${images} immagini, ${elapsed} ms)`)}`);
+        process.exit(0);
+    }
+    const flag = (name) => (args.includes(name) ? args[args.indexOf(name) + 1] : undefined);
+    const port = Number(flag('--port') ?? config.server.port);
+    const host = flag('--host') ?? process.env.MATERIALIZE_HOST;
+    let current = config;
+    // The site handler is swapped in once Astro is ready; until then visitors get a short wait page.
+    let siteHandler = (_req, res) => {
+        res.writeHead(503, { 'content-type': 'text/html; charset=utf-8', 'retry-after': '1' });
+        res.end('<meta http-equiv="refresh" content="1">Il sito si sta avviando…');
+    };
+    let production;
+    let contentChanged = () => { };
+    let redirectOf = async () => null;
+    let closeSite;
+    const updates = createUpdates({
+        site: cwd,
+        mode,
+        // The supervisor (supervisor.ts) swaps in the new version and starts the server again.
+        restart: async () => {
+            await closeSite?.();
+            await server.close();
+            process.exit(RESTART);
+        },
+    });
+    // In production the first account needs the link printed below: a fresh server online cannot be
+    // claimed by whoever finds it first.
+    const setupToken = mode === 'start' ? await installCode(cwd) : undefined;
+    const server = await startServer(config, {
+        updates,
+        setupToken,
+        port,
+        host,
+        site: withSite
+            ? async (req, res) => {
+                // Old addresses (moved pages, Impostazioni → SEO) answer with a permanent redirect.
+                if (req.method === 'GET' || req.method === 'HEAD') {
+                    const url = new URL(req.url ?? '/', 'http://site');
+                    const to = await redirectOf(url.pathname);
+                    if (to) {
+                        res.writeHead(301, { location: to + url.search });
+                        res.end();
+                        return;
+                    }
+                }
+                return siteHandler(req, res);
+            }
+            : undefined,
+        onPublish: () => {
+            void production?.rebuild();
+            contentChanged();
+        },
+    });
+    if (withSite) {
+        const runtime = await import('@materializecms/astro/runtime');
+        contentChanged = runtime.contentChanged;
+        const { setRuntime } = runtime;
+        const settings = createSettingsStore(server.database.db);
+        setRuntime({
+            config: () => current,
+            content: createContentStore(server.database.db),
+            auth: createAuthStore(server.database.db),
+            settings,
+        });
+        redirectOf = async (path) => {
+            if (/\.[a-z0-9]+$/i.test(path) && !path.endsWith('.html'))
+                return null;
+            return resolveRedirect((await settings.get('redirects')) ?? [], path);
+        };
+        if (mode === 'dev') {
+            const site = await startDevSite(cwd, port + 1);
+            siteHandler = site.handle;
+            closeSite = site.close;
+        }
+        else {
+            let built = false;
+            production = new ProductionSite(cwd, (message, success) => {
+                built = success;
+                console.log(`  ${success ? ok('✓') : fail('✗')} ${message}`);
+            });
+            siteHandler = production.handle;
+            // Under the supervisor: ready once the site is built, so a new version that cannot build it is undone.
+            void production.rebuild().then(async () => {
+                if (built)
+                    await updates.ready();
+                process.send?.(built ? 'ready' : 'failed');
+            });
+        }
+    }
+    if (!production)
+        await updates.ready().then(() => process.send?.('ready'));
+    console.log();
+    console.log(`  ${accent('Materialize')} ${dim(VERSION)}  ${config.site.name}`);
+    console.log();
+    console.log(`  ${dim((withSite ? 'Sito' : 'Locale').padEnd(12))}${server.url}`);
+    console.log(`  ${dim('Pannello')}    ${server.url}/admin`);
+    console.log(`  ${dim('API')}         ${server.url}/api/schema`);
+    console.log(`  ${dim('Database')}    ${config.database.url}`);
+    console.log(`  ${dim('Collezioni')}  ${summary(config)}`);
+    console.log();
+    if ((await createAuthStore(server.database.db).countUsers()) > 0) {
+        if (setupToken)
+            await rm(join(cwd, INSTALL_CODE), { force: true });
+    }
+    else {
+        const path = `/admin/${setupToken ? `?installa=${setupToken}` : ''}`;
+        // The public address when the site knows it (MATERIALIZE_SITE_URL in Docker or on a VPS).
+        const site = mode === 'start' ? config.site.url?.replace(/\/+$/, '') : undefined;
+        console.log(`  ${accent('Installazione')}  apri ${site ?? server.url}${path}`);
+        if (setupToken && !site)
+            console.log(dim(`                  (online: lo stesso indirizzo dal tuo dominio, https://…${path})`));
+        console.log();
+    }
+    if (mode === 'dev') {
+        let timer;
+        console.log(dim(`  In ascolto delle modifiche a ${relative(cwd, path)}…`));
+        watch(path, () => {
+            clearTimeout(timer);
+            timer = setTimeout(async () => {
+                try {
+                    const next = await loadConfig(path);
+                    server.reload(next);
+                    current = next;
+                    console.log(`  ${ok('✓')} Schema ricaricato ${dim(`(${summary(next)})`)}`);
+                }
+                catch (error) {
+                    console.log(`  ${fail('✗')} Lo schema ha un problema, resto sulla versione precedente:`);
+                    console.log(dim(describeError(error).replace(/^/gm, '    ')));
+                }
+            }, 120);
+        });
+    }
+    const stop = async () => {
+        await closeSite?.();
+        await server.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', stop);
+    process.on('SIGTERM', stop);
+}
+/**
+ * MCP over stdio, for AI clients that start a local process: the same tools as /mcp, sent to a
+ * running CMS with a personal access token. Nothing but the protocol may go to stdout.
+ */
+async function mcp(args) {
+    const token = process.env.MATERIALIZE_TOKEN?.trim();
+    if (!token) {
+        console.error('Manca MATERIALIZE_TOKEN: crea un token in Impostazioni → AI e MCP e passalo al client.');
+        process.exit(1);
+    }
+    const flag = args.indexOf('--url');
+    let url = flag >= 0 ? args[flag + 1] : process.env.MATERIALIZE_URL;
+    if (!url) {
+        const path = findConfig(process.cwd());
+        const port = path ? (await loadConfig(path)).server.port : 4321;
+        url = `http://localhost:${port}`;
+    }
+    const base = url.replace(/\/+$/, '');
+    const health = await fetch(`${base}/api/health`).catch(() => null);
+    if (!health?.ok) {
+        console.error(`Il CMS non risponde su ${base}: avvialo con materialize dev (o start), oppure indica --url.`);
+        process.exit(1);
+    }
+    const { StdioServerTransport } = await import('@modelcontextprotocol/sdk/server/stdio.js');
+    const server = createMcpServer(apiCaller(fetch, { authorization: `Bearer ${token}` }, base), VERSION);
+    await server.connect(new StdioServerTransport());
+}
+/**
+ * Puts a backup back: a database copy (content-….db), whose missing images come back from the
+ * media copy beside the backups, or a whole archive (materialize-….tar.gz: database, media and
+ * fonts). The current database is kept as a backup first, so a restore can itself be undone.
+ * The server must be stopped: it holds the database open.
+ */
+async function restore(args) {
+    const file = args.find((a) => !a.startsWith('--'));
+    const path = findConfig(process.cwd());
+    if (!file || !path) {
+        console.error(fail(!file
+            ? 'Indica il file del backup: materialize restore <file>'
+            : 'Non trovo materialize.config.ts in questa cartella.'));
+        process.exit(1);
+    }
+    const config = await loadConfig(path);
+    const head = Buffer.alloc(16);
+    try {
+        const handle = await open(resolve(file), 'r');
+        await handle.read(head, 0, 16, 0);
+        await handle.close();
+    }
+    catch {
+        console.error(fail(`Non trovo il file ${file}`));
+        process.exit(1);
+    }
+    // A SQLite file starts with "SQLite format 3", a .tar.gz with the gzip signature.
+    const archive = head[0] === 0x1f && head[1] === 0x8b;
+    if (!archive && head.toString('latin1') !== 'SQLite format 3\0') {
+        console.error(fail(`${file} non è un backup: serve un content-….db o un materialize-….tar.gz.`));
+        process.exit(1);
+    }
+    const local = config.database.url.startsWith('file:');
+    if (!local && !archive) {
+        console.error(fail('Il database è ospitato da un fornitore: ripristina il backup dal suo pannello.'));
+        process.exit(1);
+    }
+    const running = await fetch(`http://localhost:${config.server.port}/api/setup`, { signal: AbortSignal.timeout(1500) })
+        .then(() => true)
+        .catch(() => false);
+    if (running) {
+        console.error(fail(`Il server è acceso sulla porta ${config.server.port}: fermalo, poi ripeti il comando.`));
+        process.exit(1);
+    }
+    const mediaDir = resolve(config.media.dir);
+    const fontsDir = join(dirname(mediaDir), 'fonts');
+    const db = local ? resolve(config.database.url.slice('file:'.length)) : null;
+    let kept = null;
+    // The images the backup uses, read before it replaces the database (one connection, opened once).
+    let keys = [];
+    if (db) {
+        const backups = join(dirname(db), 'backups');
+        await mkdir(backups, { recursive: true });
+        const p = (n) => String(n).padStart(2, '0');
+        const d = new Date();
+        kept = join(backups, `content-${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}-prima-del-ripristino.db`);
+        // Made by SQLite, which also reads what is still in the write-ahead file.
+        const current = await openDatabase(config.database);
+        await current.client.execute({ sql: 'VACUUM INTO ?', args: [kept] });
+        if (!archive) {
+            await current.client.execute({ sql: 'ATTACH DATABASE ? AS restored', args: [resolve(file)] });
+            keys = (await current.client.execute('SELECT key FROM restored.media')).rows.map((r) => String(r.key));
+            await current.client.execute('DETACH DATABASE restored');
+        }
+        current.close();
+        // The write-ahead files belong to the old database.
+        await rm(`${db}-wal`, { force: true });
+        await rm(`${db}-shm`, { force: true });
+    }
+    if (archive) {
+        // Only what belongs where it says: the database, flat media names, fonts without "..".
+        const written = await extractTarGz(resolve(file), (name) => {
+            if (name === 'content.db')
+                return db;
+            const media = /^media\/([^/\\]+)$/.exec(name)?.[1];
+            if (media && !media.startsWith('.'))
+                return join(mediaDir, media);
+            const font = /^fonts\/(.+)$/.exec(name)?.[1];
+            if (font && !font.split('/').some((part) => part === '..' || part.startsWith('.')))
+                return join(fontsDir, font);
+            return null;
+        });
+        const media = written.filter((n) => n.startsWith('media/')).length;
+        console.log(`  ${ok('✓')} Archivio ripristinato: ${relative(process.cwd(), resolve(file))}`);
+        console.log(dim(`  ${written.includes('content.db') ? 'Database, ' : ''}${media} file dei media, ${written.length - media - (written.includes('content.db') ? 1 : 0)} file dei caratteri.`));
+    }
+    else if (db) {
+        await copyFile(resolve(file), db);
+        // The images this database uses that are no longer in the library come back from the media copy.
+        const back = await restoreMedia(db, mediaDir, keys);
+        console.log(`  ${ok('✓')} Backup ripristinato: ${relative(process.cwd(), resolve(file))}`);
+        if (back)
+            console.log(dim(`  ${back} ${back === 1 ? 'immagine tornata' : 'immagini tornate'} dalla copia dei media.`));
+    }
+    if (kept)
+        console.log(dim(`  Il database di prima è in ${relative(process.cwd(), kept)}, se servisse tornare indietro.`));
+}
+/**
+ * A one-time link for a new password, printed here: the way back in for someone who cannot get it
+ * by email, such as the only administrator of a site without email. Only who can run commands on
+ * the server can ask for it. The server may be running.
+ */
+async function resetPassword(args) {
+    const email = args
+        .find((a) => !a.startsWith('--'))
+        ?.trim()
+        .toLowerCase();
+    const path = findConfig(process.cwd());
+    if (!email || !path) {
+        console.error(fail(!email
+            ? 'Indica l’email: materialize reset-password <email>'
+            : 'Non trovo materialize.config.ts in questa cartella: lancia il comando dalla cartella del sito.'));
+        process.exit(1);
+    }
+    const config = await loadConfig(path);
+    const database = await openDatabase(config.database);
+    try {
+        const auth = createAuthStore(database.db);
+        const user = await auth.findForLogin(email);
+        if (!user) {
+            console.error(fail(`Nessun account con l’email ${email}.`));
+            process.exitCode = 1;
+            return;
+        }
+        const { token } = await auth.createInvite({
+            kind: 'reset',
+            email: user.email,
+            name: user.name,
+            role: user.role,
+            userId: user.id,
+            ttlMs: 60 * 60 * 1000,
+        });
+        await createActivityStore(database.db).record({
+            userId: null,
+            userName: '',
+            action: 'password.reset_cli',
+            target: user.email,
+            detail: null,
+            ip: 'server',
+        });
+        const base = config.site.url?.replace(/\/+$/, '') ?? `http://localhost:${config.server.port}`;
+        console.log(`  ${ok('✓')} Link per una nuova password di ${user.name} (${user.email}), valido un’ora:`);
+        console.log();
+        console.log(`    ${accent(`${base}/admin/_invite/${token}`)}`);
+        console.log();
+        console.log(dim('  Chi lo apre sceglie la password. La verifica in due passaggi, se attiva, resta.'));
+    }
+    finally {
+        database.close();
+    }
+}
+const [command = 'help', ...args] = process.argv.slice(2);
+if (command === 'dev' || command === 'start' || command === 'build') {
+    await run(command, args);
+}
+else if (command === 'mcp') {
+    await mcp(args);
+}
+else if (command === 'reset-password') {
+    await resetPassword(args);
+}
+else if (command === 'restore') {
+    await restore(args);
+}
+else if (command === '--version' || command === '-v') {
+    console.log(VERSION);
+}
+else {
+    console.log(HELP);
+    if (command !== 'help' && command !== '--help' && command !== '-h')
+        process.exitCode = 1;
+}

package/src/load-config.d.ts

@@ -0,0 +1,13 @@
+import type { MaterializeConfig } from '@materializecms/core';
+export declare const CONFIG_FILES: string[];
+export declare function findConfig(cwd: string): string | null;
+/**
+ * Imports the config fresh every time (the query string bypasses Node's module cache),
+ * so `materialize dev` can pick up schema changes without a restart.
+ */
+export declare function loadConfig(path: string): Promise<MaterializeConfig>;
+/**
+ * What belongs to the server rather than to the site, from its environment: the VPS installer
+ * (install.sh) sets these in the service, so the site's own config stays the same everywhere.
+ */
+export declare function withEnvironment(config: MaterializeConfig, env?: NodeJS.ProcessEnv): MaterializeConfig;

package/src/load-config.js

@@ -0,0 +1,53 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+export const CONFIG_FILES = ['materialize.config.ts', 'materialize.config.js', 'materialize.config.mjs'];
+export function findConfig(cwd) {
+    for (const name of CONFIG_FILES) {
+        const path = resolve(cwd, name);
+        if (existsSync(path))
+            return path;
+    }
+    return null;
+}
+/**
+ * Imports the config fresh every time (the query string bypasses Node's module cache),
+ * so `materialize dev` can pick up schema changes without a restart.
+ */
+export async function loadConfig(path) {
+    const mod = (await import(__rewriteRelativeImportExtension(`${pathToFileURL(path).href}?v=${Date.now()}`)));
+    if (!mod.default?.collections) {
+        throw new Error(`${path} must export default defineConfig({ … })`);
+    }
+    return withEnvironment(mod.default);
+}
+/**
+ * What belongs to the server rather than to the site, from its environment: the VPS installer
+ * (install.sh) sets these in the service, so the site's own config stays the same everywhere.
+ */
+export function withEnvironment(config, env = process.env) {
+    const url = env.MATERIALIZE_SITE_URL?.trim();
+    const port = Number(env.MATERIALIZE_PORT);
+    const trust = env.MATERIALIZE_TRUST_PROXY;
+    return {
+        ...config,
+        site: config.site.url || !url ? config.site : { ...config.site, url },
+        server: {
+            ...config.server,
+            port: Number.isInteger(port) && port > 0 ? port : config.server.port,
+            trustProxy: trust === '1' || trust === 'true'
+                ? true
+                : trust === '0' || trust === 'false'
+                    ? false
+                    : config.server.trustProxy,
+        },
+    };
+}

package/src/site.d.ts

@@ -0,0 +1,38 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { Fonts, MediaFiles } from '@materializecms/server';
+export declare const ASTRO_CONFIGS: string[];
+/** True when the project has an Astro site next to materialize.config.ts. */
+export declare const hasSite: (root: string) => boolean;
+export type Handler = (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
+/** Astro's dev server, mounted inside Materialize: pages render on demand from the database. */
+export declare function startDevSite(root: string, port: number): Promise<{
+    handle: Handler;
+    close: () => Promise<void>;
+}>;
+/** Builds the static site into `outDir` (client/ holds the pages, server/ the preview renderer). */
+export declare function buildSite(root: string, outDir: string): Promise<void>;
+/**
+ * Copies every library image the built pages use (originals and resized copies) into the
+ * static output, so `dist/` works on any host without the Materialize server.
+ */
+export declare function exportMedia(client: string, files: MediaFiles): Promise<number>;
+/** Writes the self-hosted fonts the built pages link to (/fonts/<id>.css and its files) into the static site. */
+export declare function exportFonts(client: string, fonts: Fonts): Promise<number>;
+/**
+ * The site in production: static files from the latest build, the preview renderer on demand,
+ * and a fresh build after every publish. Builds go to a new folder and replace the live one only
+ * when complete, so visitors never see a half-written site.
+ */
+export declare class ProductionSite {
+    private live;
+    private building;
+    private queued;
+    private readonly root;
+    private readonly builds;
+    private readonly log;
+    constructor(root: string, log: (message: string, ok: boolean) => void);
+    /** Rebuilds now, or right after the build in progress: rapid publishes coalesce into one extra build. */
+    rebuild(): Promise<void>;
+    private buildOnce;
+    handle: Handler;
+}