domma-cms 1.15.0 → 1.16.0

package/server/services/googleBusiness.js

@@ -0,0 +1,225 @@
+/** Google Business Profile: one site connection, encrypted outside authored content.
+ * Remote business data is fetched on demand. Applying a preview is an explicit SEO form edit.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import {createCipheriv, createDecipheriv, createHash, randomBytes, timingSafeEqual} from 'node:crypto';
+
+export const BUSINESS_SCOPE = 'https://www.googleapis.com/auth/business.manage';
+const TOKEN_URL = 'https://oauth2.googleapis.com/token';
+const ACCOUNT_URL = 'https://mybusinessaccountmanagement.googleapis.com/v1/accounts';
+const LOCATION_URL = 'https://mybusinessbusinessinformation.googleapis.com/v1/';
+const READ_MASK = 'name,title,storefrontAddress,phoneNumbers,websiteUri,metadata';
+const TTL = 600_000;
+const hash = value => createHash('sha256').update(String(value)).digest();
+const text = (v, max = 300) => String(v ?? '').trim().slice(0, max);
+const webAddress = v => /^https?:\/\/[^\s\\]+$/i.test(text(v, 500)) ? text(v, 500) : '';
+
+export class GoogleBusinessError extends Error {
+    constructor(message, statusCode = 400) { super(message); this.statusCode = statusCode; }
+}
+
+/** Only fields supported by the SEO organisation form; absent Google fields never clear site data. */
+export function businessPreview(location = {}) {
+    const a = location.storefrontAddress || {};
+    return {name: text(location.name), title: text(location.title),
+        organisation: {type: 'LocalBusiness', name: text(location.title), url: webAddress(location.websiteUri),
+            phone: text(location.phoneNumbers?.primaryPhone, 80),
+            sameAs: [webAddress(location.metadata?.mapsUri)].filter(Boolean),
+            address: {street: (Array.isArray(a.addressLines) ? a.addressLines : []).map(v => text(v, 200)).filter(Boolean).join(', ').slice(0, 200),
+                locality: text(a.locality, 200), region: text(a.administrativeArea, 200), postcode: text(a.postalCode, 200), country: text(a.regionCode, 200)}}};
+}
+
+export function createGoogleBusiness({directory = path.resolve('content/sessions/google-business'), fetch: fetcher = globalThis.fetch, now = Date.now} = {}) {
+    const file = path.join(directory, 'connection.json');
+    const keyFile = path.join(directory, '.key');
+    const pending = new Map();
+    let generation = 0;
+    let refreshing = null;
+
+    function key() {
+        fs.mkdirSync(directory, {recursive: true, mode: 0o700});
+        try { return fs.readFileSync(keyFile); }
+        catch (e) {
+            if (e.code !== 'ENOENT') throw e;
+            const value = randomBytes(32);
+            try { fs.writeFileSync(keyFile, value, {mode: 0o600, flag: 'wx'}); return value; }
+            catch (err) { if (err.code !== 'EEXIST') throw err; return fs.readFileSync(keyFile); }
+        }
+    }
+    function seal(value) {
+        const iv = randomBytes(12);
+        const cipher = createCipheriv('aes-256-gcm', key(), iv);
+        const bytes = Buffer.concat([cipher.update(JSON.stringify(value), 'utf8'), cipher.final()]);
+        return [iv, cipher.getAuthTag(), bytes].map(b => b.toString('base64url')).join('.');
+    }
+    function open(value) {
+        const [iv, tag, bytes] = value.split('.').map(b => Buffer.from(b, 'base64url'));
+        const cipher = createDecipheriv('aes-256-gcm', key(), iv);
+        cipher.setAuthTag(tag);
+        return JSON.parse(Buffer.concat([cipher.update(bytes), cipher.final()]).toString('utf8'));
+    }
+    function read() {
+        try { return open(JSON.parse(fs.readFileSync(file, 'utf8')).sealed); }
+        catch (e) {
+            if (e.code === 'ENOENT') return null;
+            throw new GoogleBusinessError('The saved Google connection could not be opened. Disconnect it and connect again.', 409);
+        }
+    }
+    function write(value) {
+        const temporary = `${file}.${randomBytes(6).toString('hex')}.tmp`;
+        try {
+            fs.writeFileSync(temporary, JSON.stringify({version: 1, sealed: seal(value)}) + '\n', {mode: 0o600});
+            fs.renameSync(temporary, file);
+        } finally { fs.rmSync(temporary, {force: true}); }
+    }
+    function status() {
+        let c;
+        try { c = read(); }
+        catch {
+            return {connected: false, needsReconnect: true, clientId: '', hasClientSecret: false, location: null};
+        }
+        return {connected: Boolean(c?.refreshToken), needsReconnect: c?.needsReconnect === true,
+            clientId: c?.clientId || '', hasClientSecret: Boolean(c?.clientSecret), location: c?.location || null};
+    }
+    function assertGeneration(expected) {
+        if (generation !== expected) throw new GoogleBusinessError('The Google connection changed. Open its settings again.', 409);
+    }
+    async function remote(url, options = {}) {
+        let response;
+        try { response = await fetcher(url, {...options, redirect: 'error', signal: AbortSignal.timeout(15_000)}); }
+        catch { throw new GoogleBusinessError('Google could not be reached. Try again.', 502); }
+        const body = await response.json().catch(() => ({}));
+        if (!response.ok) {
+            if (body.error === 'invalid_grant' || response.status === 401) throw new GoogleBusinessError('Google access has expired or was revoked. Connect again.', 401);
+            if (body.error === 'invalid_client') throw new GoogleBusinessError('Google rejected the client ID or secret. Check the app credentials.');
+            if (response.status === 403) throw new GoogleBusinessError('Google refused access. Check Business Profile API approval, enabled APIs and permission to manage this business.', 403);
+            if (response.status === 429) throw new GoogleBusinessError('Google Business Profile has reached its request limit. Try again later.', 429);
+            throw new GoogleBusinessError('Google could not complete the request. Check the selected business and app setup.', 502);
+        }
+        return body;
+    }
+    const tokenRequest = params => remote(TOKEN_URL, {method: 'POST', headers: {'Content-Type': 'application/x-www-form-urlencoded'}, body: new URLSearchParams(params).toString()});
+    function begin({clientId, clientSecret, redirectUri, userId}) {
+        let previous = null;
+        try { previous = read(); } catch { /* new credentials can repair an unreadable connection */ }
+        clientId = text(clientId, 300);
+        clientSecret = text(clientSecret, 2000) || (previous?.clientId === clientId ? previous.clientSecret : '');
+        if (!clientId || !clientSecret) throw new GoogleBusinessError('Enter the Google app client ID and client secret first.');
+        const uri = new URL(redirectUri);
+        if (uri.protocol !== 'https:' && !(uri.protocol === 'http:' && ['localhost', '127.0.0.1', '[::1]'].includes(uri.hostname))) {
+            throw new GoogleBusinessError('Google sign-in needs an HTTPS site address, or localhost for development.');
+        }
+        for (const [k, t] of pending) if (t.expires <= now() || t.userId === userId) pending.delete(k);
+        if (pending.size >= 200) throw new GoogleBusinessError('Too many sign-ins are pending. Try again in a few minutes.', 429);
+        const state = randomBytes(32).toString('base64url');
+        const binding = randomBytes(32).toString('base64url');
+        const verifier = randomBytes(32).toString('base64url');
+        pending.set(state, {userId, redirectUri, credentials: seal({clientId, clientSecret}), verifier, bindingHash: hash(binding), expires: now() + TTL, generation});
+        const url = new URL('https://accounts.google.com/o/oauth2/v2/auth');
+        url.search = new URLSearchParams({client_id: clientId, redirect_uri: redirectUri, response_type: 'code', scope: BUSINESS_SCOPE,
+            state, access_type: 'offline', prompt: 'consent', code_challenge: hash(verifier).toString('base64url'), code_challenge_method: 'S256'}).toString();
+        return {url: url.href, state, binding};
+    }
+    function take(state, binding) {
+        const t = pending.get(state);
+        pending.delete(state);
+        if (!t || t.expires <= now()) throw new GoogleBusinessError('This sign-in expired or was already used. Press Connect again.');
+        if (!binding || !timingSafeEqual(hash(binding), t.bindingHash)) throw new GoogleBusinessError('Finish sign-in in the browser that pressed Connect.');
+        assertGeneration(t.generation);
+        return t;
+    }
+    async function complete(ticket, code) {
+        if (!text(code, 4000)) throw new GoogleBusinessError('Google did not return a sign-in code. Connect again.');
+        const credentials = open(ticket.credentials);
+        const t = await tokenRequest({client_id: credentials.clientId, client_secret: credentials.clientSecret,
+            grant_type: 'authorization_code', code: text(code, 4000), redirect_uri: ticket.redirectUri, code_verifier: ticket.verifier});
+        if (!t.access_token || !t.refresh_token || !String(t.scope || '').split(' ').includes(BUSINESS_SCOPE)) {
+            throw new GoogleBusinessError('Google did not grant Business Profile access for this connection. Connect again and allow access.');
+        }
+        assertGeneration(ticket.generation);
+        write({...credentials, accessToken: t.access_token, refreshToken: t.refresh_token,
+            expiresAt: now() + (Number(t.expires_in) || 3600) * 1000, needsReconnect: false, location: null});
+        generation++;
+        pending.clear();
+        refreshing = null;
+        return status();
+    }
+    async function accessToken() {
+        const c = read();
+        if (!c?.refreshToken || c.needsReconnect) throw new GoogleBusinessError('Connect Google Business Profile first.', 409);
+        if (c.expiresAt > now() + 60_000) return c.accessToken;
+        if (refreshing) return refreshing;
+        const expected = generation;
+        const task = (async () => {
+            try {
+                const t = await tokenRequest({client_id: c.clientId, client_secret: c.clientSecret, refresh_token: c.refreshToken, grant_type: 'refresh_token'});
+                assertGeneration(expected);
+                if (!t.access_token) throw new GoogleBusinessError('Google did not renew access. Connect again.', 502);
+                write({...read(), accessToken: t.access_token, refreshToken: t.refresh_token || c.refreshToken,
+                    expiresAt: now() + (Number(t.expires_in) || 3600) * 1000});
+                return t.access_token;
+            } catch (e) {
+                if (e.statusCode === 401 && generation === expected) write({...read(), needsReconnect: true});
+                throw e;
+            }
+        })();
+        refreshing = task;
+        try { return await task; } finally { if (refreshing === task) refreshing = null; }
+    }
+    async function api(url) {
+        const expected = generation;
+        const token = await accessToken();
+        assertGeneration(expected);
+        try {
+            const result = await remote(url, {headers: {Authorization: `Bearer ${token}`}});
+            assertGeneration(expected);
+            return result;
+        } catch (e) {
+            if (e.statusCode === 401 && generation === expected) write({...read(), needsReconnect: true});
+            throw e;
+        }
+    }
+    function listUrl(base, pageToken, extra = {}) {
+        const url = new URL(base);
+        url.search = new URLSearchParams({...extra, ...(pageToken ? {pageToken: text(pageToken, 2000)} : {})}).toString();
+        return url.href;
+    }
+    async function accounts(pageToken) {
+        const r = await api(listUrl(ACCOUNT_URL, pageToken, {pageSize: '20'}));
+        return {accounts: (r.accounts || []).filter(a => /^accounts\/[A-Za-z0-9_-]+$/.test(a.name)).map(a => ({name: a.name, title: text(a.accountName) || a.name})), nextPageToken: r.nextPageToken || ''};
+    }
+    async function locations(account, pageToken) {
+        if (!/^accounts\/[A-Za-z0-9_-]+$/.test(account || '')) throw new GoogleBusinessError('Choose a business account.');
+        const r = await api(listUrl(`${LOCATION_URL}${account}/locations`, pageToken, {pageSize: '100', readMask: READ_MASK}));
+        return {locations: (r.locations || []).filter(l => /^locations\/[A-Za-z0-9_-]+$/.test(l.name)).map(businessPreview), nextPageToken: r.nextPageToken || ''};
+    }
+    async function select(name) {
+        if (!/^locations\/[A-Za-z0-9_-]+$/.test(name || '')) throw new GoogleBusinessError('Choose a business location.');
+        const expected = generation;
+        const location = await api(listUrl(`${LOCATION_URL}${name}`, '', {readMask: READ_MASK}));
+        if (location.name !== name) throw new GoogleBusinessError('Google returned a different business location.', 502);
+        assertGeneration(expected);
+        const preview = businessPreview(location);
+        write({...read(), location: {name: preview.name, title: preview.title}});
+        return preview;
+    }
+    async function disconnect() {
+        generation++;
+        pending.clear();
+        refreshing = null;
+        let c;
+        try { c = read(); } catch { /* forgetting an unreadable connection still works */ }
+        fs.rmSync(file, {force: true});
+        let revoked = false;
+        if (c?.refreshToken) {
+            try {
+                const r = await fetcher('https://oauth2.googleapis.com/revoke', {method: 'POST', redirect: 'error', signal: AbortSignal.timeout(15_000),
+                    headers: {'Content-Type': 'application/x-www-form-urlencoded'}, body: new URLSearchParams({token: c.refreshToken}).toString()});
+                revoked = r.ok;
+            } catch { /* the site's credential is already removed */ }
+        }
+        return {connected: false, revoked};
+    }
+    return {status, begin, take, complete, accounts, locations, select, disconnect};
+}

package/server/services/renderer.js

@@ -574,6 +574,7 @@ export async function renderPage(page, opts = {}) {
         siteJson: JSON.stringify(Object.assign(
             {
                 title: site.title,
+                ...(site.brand?.enabled === false ? {brandingEnabled: false} : {}),
                 footer: site.footer
                     ? {
                         ...site.footer,
@@ -1369,6 +1370,7 @@ export async function renderBlogPage(templatePath, data = {}, seoMeta = {}) {
         // Every `<` escaped, as on the page path above.
         siteJson: JSON.stringify({
             title: site.title,
+            ...(site.brand?.enabled === false ? {brandingEnabled: false} : {}),
             footer: site.footer
                 ? {
                     ...site.footer,

package/server/templates/page.html

@@ -188,7 +188,7 @@
     <script src="/public/js/form-logic-engine.js?v=20261025-dropzone-disable" defer></script>
 
     <!-- Site initialisation -->
-    <script src="/public/js/site.js?v=20261029-reduce-motion" type="module"></script>
+    <script src="/public/js/site.js?v=20261029-site-branding" type="module"></script>
     <script src="/public/js/collection-context.js?v=20261010-utf8-payloads" type="module"></script>
     {{ctxMenusModule}}