@materializecms/server 0.0.0-stage → 0.2.0

package/src/archive.d.ts

@@ -0,0 +1,23 @@
+import { Readable } from 'node:stream';
+/**
+ * The whole site in one file (Impostazioni → Sicurezza → Scarica tutto): a .tar.gz with the
+ * database, the original media and the downloaded fonts. Written as it is sent, so a library of
+ * several GB needs no space on the server; read back by `materialize restore`.
+ */
+export interface ArchiveEntry {
+    /** Path inside the archive: "content.db", "media/monolite-16ee2580.jpg"… */
+    name: string;
+    /** The file on disk. */
+    path: string;
+}
+/** The archive as a stream of gzip bytes. */
+export declare function tarGz(entries: ArchiveEntry[]): Readable;
+/** Every file of a folder (not the dot-folders such as .cache), as archive entries under `prefix`. */
+export declare function folderEntries(dir: string, prefix: string): Promise<ArchiveEntry[]>;
+/**
+ * Reads a .tar.gz, handing each file to `place`, which says where to write it (or null to
+ * skip it). Files are written beside their destination first, then moved into place.
+ */
+export declare function extractTarGz(file: string, place: (name: string) => string | null): Promise<string[]>;
+/** Copies a stream to a file (the archive being downloaded, in tests). */
+export declare function saveStream(stream: Readable, path: string): Promise<void>;

package/src/archive.js

@@ -0,0 +1,158 @@
+import { createReadStream, createWriteStream } from 'node:fs';
+import { mkdir, readdir, rename, stat } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { createGunzip, createGzip } from 'node:zlib';
+const BLOCK = 512;
+function octal(value, length) {
+    return `${value.toString(8).padStart(length - 1, '0')}\0`;
+}
+/** A ustar header; names longer than 100 characters go in the prefix field. */
+function header(name, size, mtime) {
+    let prefix = '';
+    let short = name;
+    if (Buffer.byteLength(name) > 100) {
+        const cut = name.lastIndexOf('/', 155);
+        prefix = name.slice(0, cut);
+        short = name.slice(cut + 1);
+        if (cut < 0 || Buffer.byteLength(short) > 100 || Buffer.byteLength(prefix) > 155)
+            throw new Error(`Name too long for the archive: ${name}`);
+    }
+    const h = Buffer.alloc(BLOCK);
+    h.write(short, 0, 100, 'utf8');
+    h.write(octal(0o644, 8), 100, 8, 'ascii');
+    h.write(octal(0, 8), 108, 8, 'ascii');
+    h.write(octal(0, 8), 116, 8, 'ascii');
+    h.write(octal(size, 12), 124, 12, 'ascii');
+    h.write(octal(Math.floor(mtime.getTime() / 1000), 12), 136, 12, 'ascii');
+    h.write('        ', 148, 8, 'ascii');
+    h.write('0', 156, 1, 'ascii');
+    h.write('ustar\0', 257, 6, 'ascii');
+    h.write('00', 263, 2, 'ascii');
+    h.write(prefix, 345, 155, 'utf8');
+    let sum = 0;
+    for (const byte of h)
+        sum += byte;
+    h.write(`${sum.toString(8).padStart(6, '0')}\0 `, 148, 8, 'ascii');
+    return h;
+}
+async function* tarBlocks(entries) {
+    for (const entry of entries) {
+        const info = await stat(entry.path).catch(() => null);
+        if (!info?.isFile())
+            continue;
+        yield header(entry.name, info.size, info.mtime);
+        let written = 0;
+        for await (const chunk of createReadStream(entry.path)) {
+            written += chunk.length;
+            yield chunk;
+        }
+        // A file that grew while being read would break the archive: it is cut to the size declared.
+        if (written !== info.size)
+            throw new Error(`${entry.name} changed while being archived`);
+        const pad = (BLOCK - (info.size % BLOCK)) % BLOCK;
+        if (pad)
+            yield Buffer.alloc(pad);
+    }
+    yield Buffer.alloc(BLOCK * 2);
+}
+/** The archive as a stream of gzip bytes. */
+export function tarGz(entries) {
+    return Readable.from(tarBlocks(entries)).pipe(createGzip());
+}
+/** Every file of a folder (not the dot-folders such as .cache), as archive entries under `prefix`. */
+export async function folderEntries(dir, prefix) {
+    const out = [];
+    const walk = async (sub) => {
+        for (const item of await readdir(join(dir, sub), { withFileTypes: true }).catch(() => [])) {
+            if (item.name.startsWith('.'))
+                continue;
+            const rel = sub ? `${sub}/${item.name}` : item.name;
+            if (item.isDirectory())
+                await walk(rel);
+            else if (item.isFile())
+                out.push({ name: `${prefix}/${rel}`, path: join(dir, rel) });
+        }
+    };
+    await walk('');
+    return out;
+}
+/**
+ * Reads a .tar.gz, handing each file to `place`, which says where to write it (or null to
+ * skip it). Files are written beside their destination first, then moved into place.
+ */
+export async function extractTarGz(file, place) {
+    const written = [];
+    let buffer = Buffer.alloc(0);
+    let current = null;
+    let ended = false;
+    const finish = async () => {
+        if (!current)
+            return;
+        const done = current;
+        current = null;
+        if (done.out) {
+            await new Promise((resolve, reject) => done.out?.end((e) => (e ? reject(e) : resolve())));
+            await rename(done.tmp, done.dest);
+            written.push(done.name);
+        }
+    };
+    const gunzip = createReadStream(file).pipe(createGunzip());
+    for await (const chunk of gunzip) {
+        buffer = Buffer.concat([buffer, chunk]);
+        while (!ended) {
+            if (current) {
+                if (current.remaining > 0) {
+                    if (!buffer.length)
+                        break;
+                    const take = Math.min(current.remaining, buffer.length);
+                    const part = buffer.subarray(0, take);
+                    if (current.out && !current.out.write(part))
+                        await new Promise((resolve) => current?.out?.once('drain', () => resolve()));
+                    current.remaining -= take;
+                    buffer = buffer.subarray(take);
+                    continue;
+                }
+                if (buffer.length < current.pad)
+                    break;
+                buffer = buffer.subarray(current.pad);
+                await finish();
+                continue;
+            }
+            if (buffer.length < BLOCK)
+                break;
+            const h = buffer.subarray(0, BLOCK);
+            buffer = buffer.subarray(BLOCK);
+            if (h.every((b) => b === 0)) {
+                ended = true;
+                break;
+            }
+            const field = (start, length) => h
+                .subarray(start, start + length)
+                .toString('utf8')
+                .replace(/\0.*$/s, '');
+            const size = Number.parseInt(field(124, 12).trim() || '0', 8);
+            const prefix = field(345, 155);
+            const name = prefix ? `${prefix}/${field(0, 100)}` : field(0, 100);
+            const type = field(156, 1);
+            const dest = type === '0' || type === '' ? place(name) : null;
+            let out = null;
+            const tmp = dest ? `${dest}.restoring` : '';
+            if (dest) {
+                await mkdir(dirname(dest), { recursive: true });
+                out = createWriteStream(tmp);
+            }
+            current = { name, remaining: size, pad: (BLOCK - (size % BLOCK)) % BLOCK, out, tmp, dest: dest ?? '' };
+        }
+        if (ended)
+            break;
+    }
+    if (current)
+        throw new Error('The archive is incomplete');
+    return written;
+}
+/** Copies a stream to a file (the archive being downloaded, in tests). */
+export async function saveStream(stream, path) {
+    await pipeline(stream, createWriteStream(path));
+}

package/src/backups.d.ts

@@ -0,0 +1,42 @@
+import type { Database } from '@materializecms/db';
+export interface Backup {
+    name: string;
+    size: number;
+    createdAt: Date;
+}
+export interface BackupSettings {
+    /** A copy every day, made by the server. */
+    enabled: boolean;
+    /** How many copies to keep; older ones are deleted. */
+    keep: number;
+}
+export declare const DEFAULT_BACKUPS: BackupSettings;
+export declare function createBackups(database: Database, mediaDir: () => string): {
+    /** False for a hosted database, or one in memory (tests). */
+    available: () => boolean;
+    folder: () => string | null;
+    list: () => Promise<Backup[]>;
+    /** A new copy; `tag` marks why ("auto", "restore"). */
+    create(tag?: string): Promise<Backup>;
+    /** Keeps the newest `keep` copies. */
+    prune(keep: number): Promise<number>;
+    /** The file of a copy, or null when the name is not one of ours. */
+    path(name: string): Promise<string | null>;
+    /** The media copy: new uploads in, files deleted long enough ago out. */
+    mirrorMedia(): Promise<{
+        copied: number;
+        purged: number;
+    }>;
+    /** How many files the media copy holds, and how much space. */
+    mediaCopy(): Promise<{
+        files: number;
+        size: number;
+    }>;
+    remove(name: string): Promise<boolean>;
+};
+export type Backups = ReturnType<typeof createBackups>;
+/**
+ * After a database is put back: the files it uses that are missing from the library, taken from
+ * the media copy next to the backups. Returns how many came back.
+ */
+export declare function restoreMedia(database: string, mediaDir: string, keys: string[]): Promise<number>;

package/src/backups.js

@@ -0,0 +1,167 @@
+import { copyFile, mkdir, readdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+/**
+ * Copies of the content database, made by SQLite itself (VACUUM INTO: consistent even while
+ * people are editing), in a backups/ folder next to it, and a copy of the uploaded files in
+ * backups/media. Only for a local database: a hosted one (Turso, libSQL) is backed up by its
+ * provider.
+ *
+ * Uploaded originals never change once saved (each has a name of its own), so the media copy
+ * only adds what is new. A file deleted from the library stays in the copy at least 30 days, and
+ * until no kept database copy is older than its deletion (those copies may still show it).
+ */
+/** How long a deleted file stays in the media copy, at least. */
+const KEEP_DELETED_MS = 30 * 24 * 60 * 60_000;
+export const DEFAULT_BACKUPS = { enabled: true, keep: 14 };
+const NAME = /^content-\d{8}-\d{6}(-[a-z0-9]+)*\.db$/;
+const stamp = (d = new Date()) => {
+    const p = (n) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+};
+export function createBackups(database, mediaDir) {
+    const file = () => {
+        const u = database.url;
+        return u.startsWith('file:') ? resolve(u.slice('file:'.length)) : null;
+    };
+    const folder = () => {
+        const f = file();
+        return f ? join(dirname(f), 'backups') : null;
+    };
+    const list = async () => {
+        const dir = folder();
+        if (!dir)
+            return [];
+        const names = (await readdir(dir).catch(() => [])).filter((n) => NAME.test(n));
+        const out = await Promise.all(names.map(async (name) => {
+            const s = await stat(join(dir, name));
+            return { name, size: s.size, createdAt: s.mtime };
+        }));
+        return out.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    };
+    return {
+        /** False for a hosted database, or one in memory (tests). */
+        available: () => !!file(),
+        folder,
+        list,
+        /** A new copy; `tag` marks why ("auto", "restore"). */
+        async create(tag) {
+            const dir = folder();
+            if (!dir)
+                throw new Error('Backups need a local database');
+            await mkdir(dir, { recursive: true });
+            const base = `content-${stamp()}${tag ? `-${tag}` : ''}`;
+            let name = `${base}.db`;
+            // Two copies in the same second keep both.
+            for (let i = 2; await stat(join(dir, name)).catch(() => null); i++)
+                name = `${base}-${i}.db`;
+            const path = join(dir, name);
+            await database.client.execute({ sql: 'VACUUM INTO ?', args: [path] });
+            const s = await stat(path);
+            return { name, size: s.size, createdAt: s.mtime };
+        },
+        /** Keeps the newest `keep` copies. */
+        async prune(keep) {
+            const dir = folder();
+            if (!dir)
+                return 0;
+            const old = (await list()).slice(Math.max(1, keep));
+            for (const b of old)
+                await rm(join(dir, b.name), { force: true });
+            return old.length;
+        },
+        /** The file of a copy, or null when the name is not one of ours. */
+        async path(name) {
+            const dir = folder();
+            if (!dir || !NAME.test(name))
+                return null;
+            const path = join(dir, name);
+            return (await stat(path).catch(() => null))?.isFile() ? path : null;
+        },
+        /** The media copy: new uploads in, files deleted long enough ago out. */
+        async mirrorMedia() {
+            const dir = folder();
+            if (!dir)
+                return { copied: 0, purged: 0 };
+            const source = resolve(mediaDir());
+            const target = join(dir, 'media');
+            await mkdir(target, { recursive: true });
+            const originals = await mediaFiles(source);
+            const copies = new Set(await mediaFiles(target));
+            let copied = 0;
+            for (const name of originals)
+                if (!copies.has(name)) {
+                    await copyFile(join(source, name), join(target, name));
+                    copied++;
+                }
+            // When each file went missing from the library, to know when it can go.
+            const ledgerPath = join(target, '.removed.json');
+            const ledger = JSON.parse(await readFile(ledgerPath, 'utf8').catch(() => '{}'));
+            const present = new Set(originals);
+            const now = Date.now();
+            const oldest = (await list()).at(-1)?.createdAt.getTime() ?? now;
+            let purged = 0;
+            for (const name of copies) {
+                if (present.has(name)) {
+                    delete ledger[name];
+                    continue;
+                }
+                ledger[name] ??= now;
+                const gone = ledger[name];
+                if (now - gone > KEEP_DELETED_MS && gone < oldest) {
+                    await rm(join(target, name), { force: true });
+                    delete ledger[name];
+                    purged++;
+                }
+            }
+            await writeFile(ledgerPath, JSON.stringify(ledger));
+            return { copied, purged };
+        },
+        /** How many files the media copy holds, and how much space. */
+        async mediaCopy() {
+            const dir = folder();
+            if (!dir)
+                return { files: 0, size: 0 };
+            const target = join(dir, 'media');
+            let size = 0;
+            const names = await mediaFiles(target);
+            for (const name of names)
+                size += (await stat(join(target, name)).catch(() => null))?.size ?? 0;
+            return { files: names.length, size };
+        },
+        async remove(name) {
+            const dir = folder();
+            if (!dir || !NAME.test(name))
+                return false;
+            const path = join(dir, name);
+            if (!(await stat(path).catch(() => null)))
+                return false;
+            await rm(path);
+            return true;
+        },
+    };
+}
+/** The files of a media folder: originals only (resized copies live in .cache and are remade). */
+async function mediaFiles(dir) {
+    const items = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    return items.filter((i) => i.isFile() && !i.name.startsWith('.')).map((i) => i.name);
+}
+/**
+ * After a database is put back: the files it uses that are missing from the library, taken from
+ * the media copy next to the backups. Returns how many came back.
+ */
+export async function restoreMedia(database, mediaDir, keys) {
+    const copy = join(dirname(database), 'backups', 'media');
+    await mkdir(mediaDir, { recursive: true });
+    let restored = 0;
+    for (const key of keys) {
+        if (!key || key.includes('/') || key.includes('\\') || key.startsWith('.'))
+            continue;
+        if (await stat(join(mediaDir, key)).catch(() => null))
+            continue;
+        if (!(await stat(join(copy, key)).catch(() => null)))
+            continue;
+        await copyFile(join(copy, key), join(mediaDir, key));
+        restored++;
+    }
+    return restored;
+}

package/src/fonts.d.ts

@@ -0,0 +1,19 @@
+export interface FontInfo {
+    id: string;
+    family: string;
+    category: string;
+    weights: number[];
+    styles: string[];
+    variable: boolean;
+}
+export declare const FONT_ID: RegExp;
+export declare const FONT_FILE: RegExp;
+export declare function createFonts(dir: string): {
+    /** Every Google Font, by family name. */
+    list(): Promise<FontInfo[]>;
+    /** @font-face rules pointing at /fonts/<id>/…, for the Latin subsets and every weight. */
+    css(id: string): Promise<string>;
+    /** A font file: from the cache, or fetched once from the CDN. */
+    file(id: string, name: string): Promise<Buffer>;
+};
+export type Fonts = ReturnType<typeof createFonts>;

package/src/fonts.js

@@ -0,0 +1,150 @@
+import { mkdir, readFile, rename, stat, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+/**
+ * Google Fonts served by the site itself. The catalog and the files come from Fontsource once,
+ * then from a local cache: visitors never contact a third party for fonts.
+ */
+const API = 'https://api.fontsource.org/v1/fonts';
+const CDN = 'https://cdn.jsdelivr.net/fontsource/fonts';
+const WEEK = 7 * 24 * 60 * 60 * 1000;
+/** Enough for Italian and the other Latin-script languages. */
+const SUBSETS = ['latin', 'latin-ext'];
+export const FONT_ID = /^[a-z0-9][a-z0-9-]{0,80}$/;
+export const FONT_FILE = /^[a-z0-9-]+-(\d{3})-(normal|italic)\.woff2$/;
+/** Fonts bundled with the panel and the starter site, listed even when the catalog cannot be reached. */
+const BUNDLED = [
+    {
+        id: 'geist',
+        family: 'Geist',
+        category: 'sans-serif',
+        weights: [400, 500, 600, 700],
+        styles: ['normal'],
+        variable: true,
+    },
+    {
+        id: 'inter',
+        family: 'Inter',
+        category: 'sans-serif',
+        weights: [400, 500, 600, 700],
+        styles: ['normal', 'italic'],
+        variable: true,
+    },
+    {
+        id: 'instrument-serif',
+        family: 'Instrument Serif',
+        category: 'serif',
+        weights: [400],
+        styles: ['normal', 'italic'],
+        variable: false,
+    },
+    {
+        id: 'fraunces',
+        family: 'Fraunces',
+        category: 'serif',
+        weights: [400, 500, 600, 700],
+        styles: ['normal', 'italic'],
+        variable: true,
+    },
+];
+export function createFonts(dir) {
+    let catalog = null;
+    async function cached(name, maxAge, load) {
+        const path = join(dir, name);
+        const info = await stat(path).catch(() => null);
+        if (info && Date.now() - info.mtimeMs < maxAge)
+            return JSON.parse(await readFile(path, 'utf8'));
+        try {
+            const value = await load();
+            await mkdir(dir, { recursive: true });
+            await writeFile(`${path}.tmp`, JSON.stringify(value));
+            await rename(`${path}.tmp`, path);
+            return value;
+        }
+        catch (error) {
+            // Offline: an old copy is better than nothing.
+            if (info)
+                return JSON.parse(await readFile(path, 'utf8'));
+            throw error;
+        }
+    }
+    async function fetchJson(url) {
+        const res = await fetch(url, { signal: AbortSignal.timeout(15_000) });
+        if (!res.ok)
+            throw new Error(`${url}: ${res.status}`);
+        return res.json();
+    }
+    async function detail(id) {
+        return cached(`${id}.json`, 30 * 24 * 60 * 60 * 1000, async () => {
+            const d = (await fetchJson(`${API}/${id}`));
+            return {
+                id: d.id,
+                family: d.family,
+                category: d.category,
+                weights: d.weights,
+                styles: d.styles,
+                variable: d.variable,
+                subsets: d.subsets,
+                unicodeRange: d.unicodeRange,
+            };
+        });
+    }
+    return {
+        /** Every Google Font, by family name. */
+        async list() {
+            if (catalog)
+                return catalog;
+            try {
+                const all = await cached('catalog.json', WEEK, async () => {
+                    const list = (await fetchJson(`${API}?type=google`));
+                    return list
+                        .filter((f) => f.subsets.includes('latin'))
+                        .map((f) => ({
+                        id: f.id,
+                        family: f.family,
+                        category: f.category,
+                        weights: f.weights,
+                        styles: f.styles,
+                        variable: f.variable,
+                    }))
+                        .sort((a, b) => a.family.localeCompare(b.family));
+                });
+                catalog = all;
+                return all;
+            }
+            catch {
+                return BUNDLED;
+            }
+        },
+        /** @font-face rules pointing at /fonts/<id>/…, for the Latin subsets and every weight. */
+        async css(id) {
+            const d = await detail(id);
+            const rules = [];
+            for (const subset of SUBSETS.filter((s) => d.subsets.includes(s))) {
+                for (const style of d.styles.filter((s) => s === 'normal' || s === 'italic')) {
+                    for (const weight of d.weights) {
+                        if (style === 'italic' && weight !== 400)
+                            continue;
+                        rules.push(`@font-face{font-family:'${d.family.replace(/'/g, '')}';font-style:${style};font-display:swap;font-weight:${weight};` +
+                            `src:url(/fonts/${id}/${subset}-${weight}-${style}.woff2) format('woff2');unicode-range:${d.unicodeRange[subset] ?? 'U+0000-00FF'}}`);
+                    }
+                }
+            }
+            return rules.join('\n');
+        },
+        /** A font file: from the cache, or fetched once from the CDN. */
+        async file(id, name) {
+            const path = join(dir, id, name);
+            const local = await readFile(path).catch(() => null);
+            if (local)
+                return local;
+            const res = await fetch(`${CDN}/${id}@latest/${name}`, { signal: AbortSignal.timeout(15_000) });
+            if (!res.ok)
+                throw new Error(`font ${id}/${name}: ${res.status}`);
+            const data = Buffer.from(await res.arrayBuffer());
+            await mkdir(join(dir, id), { recursive: true });
+            await writeFile(`${path}.tmp`, data);
+            await rename(`${path}.tmp`, path);
+            return data;
+        },
+    };
+}

package/src/index.d.ts

@@ -0,0 +1,34 @@
+import { type IncomingMessage, type ServerResponse } from 'node:http';
+import type { MaterializeConfig } from '@materializecms/core';
+import type { Updates } from '@materializecms/core/updates';
+import { type Database } from '@materializecms/db';
+export { isPatch, newer, type ReleaseNotes, type UpdateSettings, type UpdateStatus, type Updates, } from '@materializecms/core/updates';
+export { createApp, type ServerContext, VERSION } from './app.ts';
+export { extractTarGz } from './archive.ts';
+export { restoreMedia } from './backups.ts';
+export { createFonts, type FontInfo, type Fonts } from './fonts.ts';
+export { createMcpServer, registerTools } from './mcp.ts';
+export { createMediaFiles, type MediaFiles } from './media.ts';
+export { hashPassword, verifyPassword } from './password.ts';
+export { apiCaller, siteTools } from './tools.ts';
+/** Serves the public site: every request outside /api, /admin and /media goes here. */
+export type SiteHandler = (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
+export interface RunningServer {
+    url: string;
+    database: Database;
+    /** Swap the schema without restarting: used by `materialize dev` when the config changes. */
+    reload: (config: MaterializeConfig) => void;
+    close: () => Promise<void>;
+}
+export interface ServerOptions {
+    port?: number;
+    /** The address to listen on: every interface when missing, 127.0.0.1 behind a proxy on the same machine. */
+    host?: string;
+    /** The site renderer. Without one, "/" shows a status page. */
+    site?: SiteHandler;
+    onPublish?: () => void;
+    updates?: Updates;
+    /** Required by the installation in the browser while there is no account yet. */
+    setupToken?: string;
+}
+export declare function startServer(initial: MaterializeConfig, options?: ServerOptions): Promise<RunningServer>;

package/src/index.js

@@ -0,0 +1,60 @@
+import { createServer } from 'node:http';
+import { getRequestListener } from '@hono/node-server';
+import { ADMIN_DIST } from '@materializecms/admin';
+import { openDatabase } from '@materializecms/db';
+import { createApp } from './app.js';
+export { isPatch, newer, } from '@materializecms/core/updates';
+export { createApp, VERSION } from './app.js';
+export { extractTarGz } from './archive.js';
+export { restoreMedia } from './backups.js';
+export { createFonts } from './fonts.js';
+export { createMcpServer, registerTools } from './mcp.js';
+export { createMediaFiles } from './media.js';
+export { hashPassword, verifyPassword } from './password.js';
+export { apiCaller, siteTools } from './tools.js';
+const OWN = /^\/(api|admin|media|fonts|mcp)(\/|\?|$)/;
+export async function startServer(initial, options = {}) {
+    let config = initial;
+    const database = await openDatabase(config.database);
+    const app = createApp({
+        config: () => config,
+        database,
+        adminDir: ADMIN_DIST,
+        preview: !!options.site,
+        onPublish: options.onPublish,
+        updates: options.updates,
+        setupToken: options.setupToken,
+    });
+    const api = getRequestListener(app.fetch);
+    const site = options.site;
+    const server = createServer((req, res) => {
+        if (site && !OWN.test(req.url ?? '/')) {
+            Promise.resolve(site(req, res)).catch((error) => {
+                console.error(error);
+                if (!res.headersSent)
+                    res.writeHead(500).end('Errore del sito');
+            });
+            return;
+        }
+        void api(req, res);
+    });
+    const port = options.port ?? config.server.port;
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(port, options.host, resolve);
+    });
+    return {
+        url: `http://localhost:${port}`,
+        database,
+        reload: (next) => {
+            config = next;
+        },
+        close: () => new Promise((resolve) => {
+            server.close(() => {
+                database.close();
+                resolve();
+            });
+            server.closeAllConnections();
+        }),
+    };
+}