@adobe/aem-cli 16.17.1 → 16.18.0

package/src/server/HelixProject.js

@@ -15,6 +15,7 @@ import { IgnoreConfig } from '@adobe/helix-shared-config';
 import { HelixServer } from './HelixServer.js';
 import { BaseProject } from './BaseProject.js';
 import HeadHtmlSupport from './HeadHtmlSupport.js';
+import MetadataSheetSupport from './MetadataSheetSupport.js';
 import Indexer from './Indexer.js';
 
 export class HelixProject extends BaseProject {
@@ -22,6 +23,7 @@ export class HelixProject extends BaseProject {
     super(HelixServer);
     this._proxyUrl = null;
     this._headHtml = null;
+    this._metadataSheet = null;
     this._indexer = null;
     this._printIndex = false;
     this._allowInsecure = false;
@@ -42,6 +44,7 @@ export class HelixProject extends BaseProject {
   withSiteToken(value) {
     this.siteToken = value;
     this._server.withSiteToken(value);
+    this._metadataSheet?.setSiteToken(value);
     return this;
   }
 
@@ -133,6 +136,10 @@ export class HelixProject extends BaseProject {
     return this._headHtml;
   }
 
+  get metadataSheet() {
+    return this._metadataSheet;
+  }
+
   get htmlFolder() {
     return this._htmlFolder;
   }
@@ -188,6 +195,17 @@ export class HelixProject extends BaseProject {
     }
   }
 
+  async initMetadataSheet() {
+    if (this.proxyUrl) {
+      this._metadataSheet = new MetadataSheetSupport({
+        proxyUrl: this.proxyUrl,
+        log: this.log,
+        allowInsecure: this.allowInsecure,
+        siteToken: this.siteToken,
+      });
+    }
+  }
+
   async init404Html() {
     if (this.proxyUrl) {
       this._file404html = resolve(this.directory, '404.html');
@@ -249,6 +267,7 @@ export class HelixProject extends BaseProject {
     this.log.debug('Launching AEM dev server...');
     await super.start();
     await this.initHeadHtml();
+    await this.initMetadataSheet();
     await this.init404Html();
     await this.initHtmlFolder();
     await this.initHlxIgnore();

package/src/server/HelixServer.js

@@ -20,10 +20,32 @@ import RequestContext from './RequestContext.js';
 import { asyncHandler, BaseServer } from './BaseServer.js';
 import LiveReload from './LiveReload.js';
 import { saveSiteTokenToFile } from '../config/config-utils.js';
+import { CONTENT_DIR } from '../content/content-shared.js';
+import { transformContentMetadataHtml } from '../content/content-metadata-html.js';
 
 const LOGIN_ROUTE = '/.aem/cli/login';
 const LOGIN_ACK_ROUTE = '/.aem/cli/login/ack';
 
+/**
+ * @param {import('express').Request} req
+ * @param {import('./RequestContext.js').default} ctx
+ * @returns {string}
+ */
+function absolutePageUrlFromRequest(req, ctx) {
+  const raw = req.headers['x-forwarded-proto'];
+  const proto = (Array.isArray(raw) ? raw[0] : raw) || req.protocol || 'http';
+  const host = req.get('host');
+  if (!host) {
+    return '';
+  }
+  try {
+    const pathWithQuery = req.originalUrl || ctx.url;
+    return new URL(pathWithQuery, `${proto}://${host}`).href;
+  } catch {
+    return '';
+  }
+}
+
 export class HelixServer extends BaseServer {
   /**
    * Creates a new HelixServer for the given project.
@@ -149,6 +171,7 @@ export class HelixServer extends BaseServer {
 
         this.withSiteToken(siteToken);
         this._project.headHtml.setSiteToken(siteToken);
+        this._project.metadataSheet?.setSiteToken(siteToken);
         await saveSiteTokenToFile(siteToken);
         this.log.info('Site token received and saved to file.');
 
@@ -371,6 +394,65 @@ export class HelixServer extends BaseServer {
 
     // try to serve static
     try {
+      // Check content/ first — prefer local content checkout over proxy
+      const contentDir = path.join(this._project.directory, CONTENT_DIR);
+      const contentFilePath = path.join(contentDir, ctx.path);
+      if (!path.relative(contentDir, contentFilePath).startsWith('..')) {
+        try {
+          if (contentFilePath.endsWith('.html')) {
+            // readFile throws EISDIR for directories and ENOENT for missing files
+            let htmlContent = await readFile(contentFilePath, 'utf-8');
+            const absolutePageUrl = absolutePageUrlFromRequest(req, ctx);
+            if (this._project.metadataSheet) {
+              this._project.metadataSheet.setCookie(req.headers.cookie || '');
+              await this._project.metadataSheet.ensureLoaded();
+            }
+            const sheetRow = this._project.metadataSheet?.matchPath(ctx.path) ?? null;
+            const { htmlFragment, metaTagsHtml } = transformContentMetadataHtml(htmlContent, {
+              absolutePageUrl,
+              sheetRow,
+            });
+            htmlContent = htmlFragment;
+            // content/ files are plain HTML (body only, no <head>)
+            // wrap with a full document and inject local head.html
+            if (!htmlContent.includes('<head>')) {
+              await this._project.headHtml.update();
+              const headHtml = this._project.headHtml.localHtml || '';
+              htmlContent = `<html><head>${headHtml}${metaTagsHtml}</head>${htmlContent}</html>`;
+            } else {
+              await this._project.headHtml.setCookie(req.headers.cookie);
+              htmlContent = await this._project.headHtml.replace(htmlContent);
+              if (metaTagsHtml) {
+                htmlContent = htmlContent.replace(/<\/head>/i, `${metaTagsHtml}</head>`);
+              }
+            }
+            if (liveReload) {
+              htmlContent = utils.injectLiveReloadScript(htmlContent, this);
+              liveReload.registerFile(ctx.requestId, contentFilePath);
+            }
+            res.set({
+              'content-type': 'text/html; charset=utf-8',
+              'access-control-allow-origin': '*',
+            });
+            res.send(htmlContent);
+            log.debug(`${pfx}served from ${CONTENT_DIR}/: ${ctx.path}`);
+            return;
+          }
+          // sendFile throws EISDIR for directories and ENOENT for missing files
+          await sendFile(contentFilePath, {
+            dotfiles: 'allow',
+            headers: { 'access-control-allow-origin': '*' },
+          });
+          if (liveReload) {
+            liveReload.registerFile(ctx.requestId, contentFilePath);
+          }
+          log.debug(`${pfx}served from ${CONTENT_DIR}/: ${ctx.path}`);
+          return;
+        } catch (e) {
+          log.debug(`${pfx}${CONTENT_DIR}/ miss for ${ctx.path}: ${e.code}`);
+        }
+      }
+
       // Check if it's an HTML file and live reload is enabled
       if (liveReload && filePath.endsWith('.html')) {
         // Read the HTML file and inject the livereload script

package/src/server/MetadataSheetSupport.js

@@ -0,0 +1,221 @@
+/*
+ * Copyright 2026 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import globToRegExp from 'glob-to-regexp';
+import { getFetch } from '../fetch-utils.js';
+
+/**
+ * Normalizes the request path for matching against metadata.json URL globs.
+ * @param {string} pathname
+ * @returns {string}
+ */
+export function normalizePathForMetadataMatch(pathname) {
+  let p = pathname || '/';
+  if (!p.startsWith('/')) {
+    p = `/${p}`;
+  }
+  if (p.length > 5 && p.endsWith('.html')) {
+    p = p.slice(0, -5);
+  }
+  return p || '/';
+}
+
+/**
+ * @param {unknown} body
+ * @returns {object[]}
+ */
+function extractDataRows(body) {
+  if (!body || typeof body !== 'object') {
+    return [];
+  }
+  const { data } = /** @type {{ data?: unknown }} */ (body);
+  if (!Array.isArray(data)) {
+    return [];
+  }
+  return /** @type {object[]} */ (data.filter((r) => r && typeof r === 'object'));
+}
+
+/**
+ * @param {object[]} rows
+ * @returns {Array<{ pattern: string, regex: RegExp, row: object }>}
+ */
+export function compileMetadataSheetPatterns(rows) {
+  /** @type {Array<{ pattern: string, regex: RegExp, row: object }>} */
+  const out = [];
+  for (const row of rows) {
+    const pattern = row.URL;
+    if (typeof pattern !== 'string' || !pattern.trim()) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+    try {
+      const regex = globToRegExp(pattern, { globstar: true });
+      out.push({ pattern, regex, row });
+    } catch {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+  }
+  return out;
+}
+
+/**
+ * Merges all matching metadata sheet rows for a path: most specific URL pattern first,
+ * then each field uses the first non-empty value (empty string falls through to broader rows).
+ * @param {string} normalizedPath
+ * @param {Array<{ pattern: string, regex: RegExp, row: object }>} compiled
+ * @returns {Record<string, string> | null}
+ */
+export function mergeMetadataSheetRows(normalizedPath, compiled) {
+  /** @type {Array<{ pattern: string, row: object }>} */
+  const hits = [];
+  for (const { pattern, regex, row } of compiled) {
+    if (regex.test(normalizedPath)) {
+      hits.push({ pattern, row });
+    }
+  }
+  if (hits.length === 0) {
+    return null;
+  }
+  hits.sort((a, b) => b.pattern.length - a.pattern.length);
+
+  /** @type {Set<string>} */
+  const keys = new Set();
+  for (const { row } of hits) {
+    for (const k of Object.keys(row)) {
+      if (k !== 'URL' && !k.startsWith(':')) {
+        keys.add(k);
+      }
+    }
+  }
+
+  /** @type {Record<string, string>} */
+  const merged = {};
+  for (const key of keys) {
+    for (const { row } of hits) {
+      const v = row[key];
+      if (v === undefined || v === null) {
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+      const s = String(v).trim();
+      if (s === '') {
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+      merged[key] = s;
+      break;
+    }
+  }
+
+  return Object.keys(merged).length > 0 ? merged : null;
+}
+
+export default class MetadataSheetSupport {
+  /**
+   * @param {{ proxyUrl: string, log: object, allowInsecure: boolean, siteToken?: string }} opts
+   */
+  constructor({
+    proxyUrl, log, allowInsecure, siteToken,
+  }) {
+    this.url = new URL(proxyUrl);
+    this.url.pathname = '/metadata.json';
+    this.log = log;
+    this.allowInsecure = allowInsecure;
+    this.siteToken = siteToken || '';
+    this.cookie = '';
+    /** @type {Array<{ pattern: string, regex: RegExp, row: object }> | null} */
+    this._compiled = null;
+    /** @type {Promise<void> | null} */
+    this._loadPromise = null;
+  }
+
+  setCookie(cookie) {
+    const next = cookie || '';
+    if (this.cookie !== next) {
+      this.cookie = next;
+      this._compiled = null;
+      this._loadPromise = null;
+    }
+  }
+
+  setSiteToken(siteToken) {
+    const next = siteToken || '';
+    if (this.siteToken !== next) {
+      this.siteToken = next;
+      this._compiled = null;
+      this._loadPromise = null;
+    }
+  }
+
+  invalidate() {
+    this._compiled = null;
+    this._loadPromise = null;
+  }
+
+  async ensureLoaded() {
+    if (this._compiled !== null) {
+      return;
+    }
+    if (this._loadPromise) {
+      await this._loadPromise;
+      return;
+    }
+    this._loadPromise = this._fetchAndCompile();
+    try {
+      await this._loadPromise;
+    } finally {
+      this._loadPromise = null;
+    }
+  }
+
+  async _fetchAndCompile() {
+    const headers = {};
+    if (this.cookie) {
+      headers.cookie = this.cookie;
+    }
+    if (this.siteToken) {
+      headers.authorization = `token ${this.siteToken}`;
+    }
+    try {
+      const resp = await getFetch(this.allowInsecure)(this.url, {
+        cache: 'no-store',
+        headers,
+      });
+      if (!resp.ok) {
+        this.log.debug(`metadata.json not loaded (${resp.status}) from ${this.url}`);
+        this._compiled = [];
+        return;
+      }
+      const text = await resp.text();
+      const body = JSON.parse(text);
+      const rows = extractDataRows(body);
+      this._compiled = compileMetadataSheetPatterns(rows);
+      this.log.debug(`loaded metadata.json (${this._compiled.length} URL pattern(s)) from ${this.url}`);
+    } catch (e) {
+      this.log.debug(`metadata.json fetch/parse failed: ${e.message || e}`);
+      this._compiled = [];
+    }
+  }
+
+  /**
+   * @param {string} pathname ctx.path or resource path with .html
+   * @returns {object | null}
+   */
+  matchPath(pathname) {
+    if (!this._compiled || this._compiled.length === 0) {
+      return null;
+    }
+    const normalized = normalizePathForMetadataMatch(pathname);
+    return mergeMetadataSheetRows(normalized, this._compiled);
+  }
+}