@adobe/aem-cli 15.0.0

package/src/log-common.js

@@ -0,0 +1,132 @@
+/*
+ * Copyright 2018 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 path from 'path';
+import fs from 'fs-extra';
+import chalk from 'chalk-template';
+import {
+  ConsoleLogger,
+  FileLogger,
+  messageFormatJsonString,
+  messageFormatTechnical, MultiLogger,
+  serializeMessage,
+  SimpleInterface,
+} from '@adobe/helix-log';
+
+const LEVEL_NAMES = {
+  info: chalk`{green info}`,
+  warn: chalk`{yellow warn}`,
+  error: chalk`{red error}`,
+};
+
+/**
+ * Log message filter that removes log entries produced during a progress bar
+ * (fields.progress === true), but only on a tty.
+ */
+const suppressProgress = (fields) => {
+  // eslint-disable-next-line no-underscore-dangle,no-console
+  if (fields.progress && console._stderr.isTTY) {
+    return undefined;
+  }
+  // eslint-disable-next-line no-param-reassign
+  delete fields.progress;
+  return fields;
+};
+
+/**
+ * Log message filter that removes the `progress` field so that it doesn't get logged.
+ */
+const filterProgress = (fields) => {
+  // eslint-disable-next-line no-param-reassign
+  delete fields.progress;
+  return fields;
+};
+
+/**
+ * Message format for the console that doesn't show the `info` level keyword for the `cli`
+ * category. prefixes the log entries with the category otherwise.
+ */
+const categoryAwareMessageFormatConsole = (fields) => {
+  // eslint-disable-next-line
+  const {level, timestamp, message, category = 'cli', ...rest} = fields;
+
+  const fullMsg = Object.keys(rest).length === 0 ? message : [...message, ' ', rest];
+  const ser = serializeMessage(fullMsg, { colors: false });
+
+  const lvl = LEVEL_NAMES[level] ?? level.toLowerCase();
+  if (category === 'cli' && level === 'info') {
+    return `${ser}`;
+  }
+  return `${lvl}: ${ser}`;
+};
+
+// module global loggers by category
+const loggersByCategory = new Map();
+
+/**
+ * Gets the logger for the respective category or creates a new one if it does not exist yet.
+ * @param {object|string} [config='cli'] The log config or the category name.
+ * @param {string} [config.category='cli'] The log category
+ * @param {string} [config.level='cli'] The log level
+ * @param {string} [config.logsDir='logs'] The log directory.
+ * @param {Array|string} [config.logFle=['-', '${category}-server.log']] The log files(s).
+ *
+ * @returns {SimpleInterface} a helix-log simple interface.
+ */
+export function getOrCreateLogger(config = 'cli') {
+  let categ;
+  if (typeof config === 'string') {
+    categ = config;
+  } else {
+    categ = (config && config.category) || 'cli';
+  }
+
+  if (loggersByCategory.has(categ)) {
+    return loggersByCategory.get(categ);
+  }
+
+  // setup helix logger
+  const level = (config && config.logLevel) || 'info';
+  const logsDir = path.normalize((config && config.logsDir) || 'logs');
+  const logFiles = config && Array.isArray(config.logFile)
+    ? config.logFile
+    : ['-', (config && config.logFile) || path.join(logsDir, `${categ}-server.log`)];
+
+  const loggers = new Map();
+  logFiles.forEach((logFile) => {
+    const name = loggers.has('default') ? logFile : 'default';
+    if (logFile === '-') {
+      loggers.set(name, new ConsoleLogger({
+        filter: categ === 'cli' ? suppressProgress : filterProgress,
+        level,
+        formatter: categoryAwareMessageFormatConsole,
+      }));
+    } else {
+      fs.ensureDirSync(path.dirname(logFile));
+      loggers.set(name, new FileLogger(logFile, {
+        level: 'debug',
+        formatter: /\.json/.test(logFile) ? messageFormatJsonString : messageFormatTechnical,
+      }));
+    }
+  });
+
+  // create simple interface
+  const log = new SimpleInterface({
+    level,
+    defaultFields: {
+      category: categ,
+    },
+    logger: new MultiLogger(loggers),
+  });
+
+  loggersByCategory.set(categ, log);
+  return log;
+}

package/src/md5.js

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2018 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 crypto from 'crypto';
+import fs from 'fs';
+
+export default function md5(string, encoding = 'hex') {
+  return crypto
+    .createHash('md5')
+    .update(string)
+    .digest(encoding);
+}
+
+md5.file = async function md5File(filename) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash('md5').setEncoding('hex');
+    fs.createReadStream(filename)
+      .on('data', (data) => {
+        hash.update(data);
+      })
+      .on('end', () => {
+        resolve(hash.digest('hex'));
+      })
+      .on('error', reject);
+  });
+};

package/src/package.cjs

@@ -0,0 +1,12 @@
+/*
+ * Copyright 2021 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.
+ */
+module.exports = require('../package.json');

package/src/server/BaseProject.js

@@ -0,0 +1,137 @@
+/*
+ * Copyright 2018 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 EventEmitter from 'events';
+import { ConsoleLogger, deriveLogger, SimpleInterface } from '@adobe/helix-log';
+
+export class BaseProject extends EventEmitter {
+  constructor(Server) {
+    super();
+    this._cwd = process.cwd();
+    this._server = new Server(this);
+    this._server.on('stopped', async () => {
+      await this.stop();
+    });
+    this._stopping = false;
+    this._logger = null;
+    this._cacheDirectory = null;
+    this._kill = false;
+  }
+
+  withCwd(cwd) {
+    this._cwd = cwd;
+    return this;
+  }
+
+  withKill(kill) {
+    this._kill = !!kill;
+    return this;
+  }
+
+  withHttpPort(port) {
+    this._server.withPort(port);
+    return this;
+  }
+
+  withBindAddr(addr) {
+    this._server.withAddr(addr);
+    return this;
+  }
+
+  withTLS(key, cert) {
+    this._server.withTLS(key, cert);
+    return this;
+  }
+
+  withLogger(logger) {
+    this._logger = logger;
+    return this;
+  }
+
+  withCacheDirectory(value) {
+    this._cacheDirectory = value;
+    return this;
+  }
+
+  get log() {
+    return this._logger;
+  }
+
+  get started() {
+    return this._server.isStarted();
+  }
+
+  get cacheDirectory() {
+    return this._cacheDirectory;
+  }
+
+  get directory() {
+    return this._cwd;
+  }
+
+  get kill() {
+    return this._kill;
+  }
+
+  /**
+   * Returns the helix server
+   * @returns {HelixServer}
+   */
+  get server() {
+    return this._server;
+  }
+
+  async init() {
+    if (!this._logger) {
+      this._logger = new SimpleInterface({
+        logger: new ConsoleLogger(),
+        level: 'debug',
+        defaultFields: {
+          category: 'hlx',
+        },
+        filter: (fields) => {
+          // eslint-disable-next-line no-param-reassign
+          fields.message[0] = `[${fields.category}] ${fields.message[0]}`;
+          // eslint-disable-next-line no-param-reassign
+          delete fields.category;
+          return fields;
+        },
+      });
+    } else {
+      this._logger = deriveLogger(this._logger, {
+        defaultFields: {
+          category: 'hlx',
+        },
+      });
+    }
+    return this;
+  }
+
+  async start() {
+    await this._server.start(this);
+    return this;
+  }
+
+  async doStop() {
+    await this._server.stop();
+  }
+
+  async stop() {
+    if (this._stopping) {
+      return this;
+    }
+    this._stopping = true;
+    this.emit('stopping');
+    await this.doStop();
+    this.emit('stopped');
+    return this;
+  }
+}

package/src/server/BaseServer.js

@@ -0,0 +1,205 @@
+/*
+ * Copyright 2018 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 https from 'https';
+import EventEmitter from 'events';
+import express from 'express';
+import cookieParser from 'cookie-parser';
+import { getFetch } from '../fetch-utils.js';
+import utils from './utils.js';
+import packageJson from '../package.cjs';
+
+const DEFAULT_PORT = 3000;
+
+/**
+ * Wraps the route middleware so it can catch potential promise rejections
+ * during the async invocation.
+ *
+ * @param {ExpressMiddleware} fn an extended express middleware function
+ * @returns {ExpressMiddleware} an express middleware function.
+ */
+export function asyncHandler(fn) {
+  return (req, res, next) => (Promise.resolve(fn(req, res, next)).catch(next));
+}
+
+export class BaseServer extends EventEmitter {
+  /**
+   * Creates a new HelixServer for the given project.
+   * @param {BaseProject} project
+   */
+  constructor(project) {
+    super();
+    this._project = project;
+    this._app = express();
+    this._port = DEFAULT_PORT;
+    this._addr = '127.0.0.1';
+    this._tls = false;
+    this._scheme = 'http';
+    this._key = '';
+    this._cert = '';
+    this._server = null;
+    this._sockets = new Set();
+  }
+
+  /**
+   * Returns the logger.
+   * @returns {Logger} the logger.
+   */
+  get log() {
+    return this._project.log;
+  }
+
+  async setupApp() {
+    this._app.use(cookieParser());
+    this._app.get('/.kill', async (req, res) => {
+      res.send('Goodbye!');
+      this.stop();
+    });
+  }
+
+  withPort(port) {
+    this._port = port;
+    return this;
+  }
+
+  withAddr(addr) {
+    // prefer IPv4
+    this._addr = addr === '*' ? '0.0.0.0' : addr;
+    return this;
+  }
+
+  withTLS(key, cert) {
+    this._tls = true;
+    this._scheme = 'https';
+    this._key = key;
+    this._cert = cert;
+    return this;
+  }
+
+  isStarted() {
+    return this._server !== null;
+  }
+
+  get port() {
+    return this._port;
+  }
+
+  get addr() {
+    return this._addr;
+  }
+
+  get hostname() {
+    return this._addr === '127.0.0.1' || this._addr === '0.0.0.0'
+      ? 'localhost'
+      : this._addr;
+  }
+
+  get scheme() {
+    return this._scheme;
+  }
+
+  get app() {
+    return this._app;
+  }
+
+  async start() {
+    const { log } = this;
+    if (this._port !== 0) {
+      let retries = 1;
+      if (this._project.kill && await utils.checkPortInUse(this._port, this._addr)) {
+        try {
+          const res = await getFetch()(`${this._scheme}://${this._addr}:${this._port}/.kill`);
+          await res.text();
+        } catch (e) {
+          // ignore errors, in case the other server closes connection
+        }
+        retries = 10;
+      }
+      let inUse = true;
+      while (inUse && retries > 0) {
+        // eslint-disable-next-line no-await-in-loop
+        inUse = await utils.checkPortInUse(this._port, this._addr);
+        if (inUse) {
+          // eslint-disable-next-line no-await-in-loop,no-promise-executor-return
+          await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        retries -= 1;
+      }
+      if (inUse) {
+        throw new Error(`Port ${this._port} already in use by another process.`);
+      }
+    }
+    log.info(`Starting AEM dev server v${packageJson.version}`);
+    await new Promise((resolve, reject) => {
+      const listenCb = (err) => {
+        if (err) {
+          reject(new Error(`Error while starting ${this._scheme} server: ${err}`));
+        }
+        this._port = this._server.address().port;
+        this._addr = this._server.address().address;
+        log.info(`Local AEM dev server up and running: ${this.scheme}://${this.hostname}:${this.port}/`);
+        if (this._project.proxyUrl) {
+          log.info(`Enabled reverse proxy to ${this._project.proxyUrl}`);
+        }
+        this._server.on('connection', (socket) => {
+          log.debug(`new connection from ${socket.remoteAddress}:${socket.remotePort}`);
+          this._sockets.add(socket);
+          socket.once('close', () => {
+            log.debug(`closed connection from ${socket.remoteAddress}:${socket.remotePort}`);
+            this._sockets.delete(socket);
+          });
+        });
+        resolve();
+      };
+      if (this._tls) {
+        this._server = https.createServer({
+          key: this._key,
+          cert: this._cert,
+        }, this._app);
+        this._server.listen(this._port, this._addr, listenCb);
+      } else {
+        this._server = this._app.listen(this._port, this._addr, listenCb);
+      }
+    });
+    await this.setupApp();
+    this.emit('started', this.server);
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async doStop() {
+    // ignore
+  }
+
+  async stop() {
+    if (!this._server) {
+      return;
+    }
+    const server = this._server;
+    this._server = null;
+    this.emit('stopping');
+    await new Promise((resolve, reject) => {
+      this.log.debug('Stopping AEM dev server..');
+      for (const socket of this._sockets) {
+        socket.destroy();
+        this._sockets.delete(socket);
+      }
+      server.close((err) => {
+        if (err) {
+          reject(new Error(`Error while stopping http server: ${err}`));
+        }
+        this.log.info('AEM dev server stopped.');
+        resolve();
+      });
+    });
+    await this.doStop();
+    this.emit('stopped');
+  }
+}

package/src/server/HeadHtmlSupport.js

@@ -0,0 +1,180 @@
+/*
+ * Copyright 2021 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 fs from 'fs/promises';
+import { createHash } from 'crypto';
+import { resolve } from 'path';
+import { unified } from 'unified';
+import rehypeParse from 'rehype-parse';
+import { select } from 'hast-util-select';
+import { getFetch } from '../fetch-utils.js';
+
+export default class HeadHtmlSupport {
+  /**
+   * prepares the dom tree for easy comparison. it hashes the nodes and stored them in
+   * a `hash` property. It also removes all whitespace-empty text nodes.
+   *
+   * @param tree
+   * @returns {string}
+   */
+  static hash(tree) {
+    const h = createHash('sha1');
+
+    const update = (obj, keys) => {
+      keys.sort();
+      for (const k of keys) {
+        let v = obj[k];
+        if (v !== undefined) {
+          if (Array.isArray(v)) {
+            v = JSON.stringify(v);
+          }
+          h.update(String(v));
+        }
+      }
+    };
+
+    update(tree, ['type', 'tagName', 'value']);
+    if (tree.properties) {
+      update(tree.properties, Object.keys(tree.properties));
+    }
+
+    if (tree.children) {
+      for (let i = 0; i < tree.children.length; i += 1) {
+        const child = tree.children[i];
+        // remove empty text nodes
+        if (child.type === 'text' && child.value.trim() === '') {
+          tree.children.splice(i, 1);
+          i -= 1;
+        } else {
+          h.update(HeadHtmlSupport.hash(child));
+        }
+      }
+    }
+
+    // eslint-disable-next-line no-param-reassign
+    tree.hash = h.digest('base64');
+    return tree.hash;
+  }
+
+  /**
+   * Parses the html and returns the dom
+   * @param {string} html
+   * @returns {Promise<HastNode>}
+   */
+  static async toDom(html) {
+    return unified()
+      .use(rehypeParse, { fragment: true })
+      .parse(html);
+  }
+
+  constructor({ proxyUrl, directory, log }) {
+    this.remoteHtml = '';
+    this.remoteDom = null;
+    this.remoteStatus = 0;
+    this.localHtml = '';
+    this.localStatus = 0;
+    this.url = new URL(proxyUrl);
+    this.url.pathname = '/head.html';
+    this.filePath = resolve(directory, 'head.html');
+    this.log = log;
+  }
+
+  async loadRemote() {
+    // load head from server
+    const resp = await getFetch()(this.url, {
+      cache: 'no-store',
+    });
+    this.remoteStatus = resp.status;
+    if (resp.ok) {
+      this.remoteHtml = (await resp.text()).trim();
+      this.remoteDom = await HeadHtmlSupport.toDom(this.remoteHtml);
+      HeadHtmlSupport.hash(this.remoteDom);
+      this.log.debug(`loaded remote head.html from from ${this.url}`);
+    } else {
+      this.log.error(`error while loading head.html from ${this.url}: ${resp.status}`);
+    }
+  }
+
+  async loadLocal() {
+    try {
+      this.localHtml = (await fs.readFile(this.filePath, 'utf-8')).trim();
+      this.localStatus = 200;
+      this.log.debug('loaded local head.html from from', this.filePath);
+    } catch (e) {
+      this.log.error(`error while loading local head.html from ${this.filePath}: ${e.code}`);
+      this.localStatus = 404;
+    }
+  }
+
+  async init() {
+    if (!this.localStatus) {
+      await this.loadLocal();
+    }
+    if (!this.remoteStatus) {
+      await this.loadRemote();
+    }
+    this.isModified = this.localStatus === 200
+      && this.remoteStatus === 200
+      && this.localHtml !== this.remoteHtml;
+  }
+
+  async replace(source) {
+    if (!this.isModified) {
+      this.log.trace('head.html ignored: not modified locally.');
+      return source;
+    }
+
+    const $html = await unified()
+      .use(rehypeParse)
+      .parse(source);
+
+    const $head = select('head', $html);
+    if (!$head) {
+      this.log.trace('head.html ignored: source html has no matching <head>...</head> pair.');
+      return source;
+    }
+
+    const $dst = this.remoteDom;
+    if (!$dst) {
+      // inject local content and the end of the head
+      const $last = $head.children[$head.children.length - 1];
+      const to = $last.position.end.offset;
+      return `${source.substring(0, to)}${this.localHtml}${source.substring(to)}`;
+    }
+
+    // find remote head elements in source head
+    HeadHtmlSupport.hash($head);
+    const srcLen = $head.children.length;
+    const dstLen = $dst.children.length;
+
+    let $first;
+    let $last;
+    for (let s = 0; !$last && s <= srcLen - dstLen; s += 1) {
+      $first = $head.children[s];
+      for (let d = 0; d < dstLen; d += 1) {
+        $last = $head.children[s + d];
+        if ($last.hash !== $dst.children[d].hash) {
+          $last = null;
+          break;
+        }
+      }
+    }
+
+    if (!$last) {
+      this.log.debug('head.html ignored: remote not found in HTML.');
+      return source;
+    }
+
+    const from = $first.position.start.offset;
+    const to = $last.position.end.offset;
+    return `${source.substring(0, from)}${this.localHtml}${source.substring(to)}`;
+  }
+}