@adobe/aem-cli 16.17.1 → 16.18.0

package/src/content/merge.cmd.js

@@ -0,0 +1,150 @@
+/*
+ * 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 fs from 'fs';
+import path from 'path';
+import fse from 'fs-extra';
+import git from 'isomorphic-git';
+import { diff3Merge } from 'node-diff3'; // eslint-disable-line import/no-unresolved
+import { DaClient } from './da-api.js';
+import { getValidToken } from './da-auth.js';
+import { CONTENT_DIR, CONFIG_FILE } from './content-shared.js';
+
+/**
+ * 3-way merge using diff3 algorithm.
+ * Returns { text, conflict }.
+ */
+function threeWayMerge(base, local, remote) {
+  const baseLines = base.split('\n');
+  const localLines = local.split('\n');
+  const remoteLines = remote.split('\n');
+
+  const regions = diff3Merge(localLines, baseLines, remoteLines);
+
+  const out = [];
+  let hasConflict = false;
+
+  for (const region of regions) {
+    if (region.ok) {
+      out.push(...region.ok);
+    } else {
+      out.push('<<<<<<< LOCAL', ...region.conflict.a, '=======', ...region.conflict.b, '>>>>>>> REMOTE');
+      hasConflict = true;
+    }
+  }
+
+  return { text: out.join('\n'), conflict: hasConflict };
+}
+
+export default class MergeCommand {
+  constructor(logger) {
+    this.log = logger;
+    this._dir = process.cwd();
+    this._filePath = null;
+  }
+
+  withDirectory(dir) {
+    this._dir = dir;
+    return this;
+  }
+
+  withToken(token) {
+    this._token = token;
+    return this;
+  }
+
+  withFilePath(filePath) {
+    this._filePath = filePath || null;
+    return this;
+  }
+
+  async run() {
+    const { log } = this;
+    const contentDir = path.resolve(this._dir, CONTENT_DIR);
+    const configPath = path.join(contentDir, CONFIG_FILE);
+
+    if (!await fse.pathExists(configPath)) {
+      throw new Error('No config found. Run \'aem content clone\' first.');
+    }
+    const { org, repo } = await fse.readJson(configPath);
+
+    // Find locally changed files via git
+    const matrix = await git.statusMatrix({ fs, dir: contentDir });
+    let changedPaths = matrix
+      .filter(([, head, workdir]) => head === 1 && workdir === 2)
+      .map(([filepath]) => `/${filepath}`);
+
+    if (this._filePath) {
+      const needle = this._filePath.startsWith('/') ? this._filePath : `/${this._filePath}`;
+      changedPaths = changedPaths.filter((p) => p === needle);
+      if (changedPaths.length === 0) {
+        log.info(`No local changes detected for ${needle}`);
+        return;
+      }
+    }
+
+    if (changedPaths.length === 0) {
+      log.info('Nothing to merge. No locally modified files.');
+      return;
+    }
+
+    const token = await getValidToken(log, this._token, contentDir);
+    const client = new DaClient(token);
+
+    // Get the HEAD commit to read base blobs
+    const [headCommit] = await git.log({ fs, dir: contentDir, depth: 1 });
+
+    let cleanCount = 0;
+    let conflictCount = 0;
+
+    for (const daPath of changedPaths) {
+      const relPath = daPath.slice(1); // strip leading /
+      const localPath = path.join(contentDir, ...daPath.split('/').filter(Boolean));
+
+      // eslint-disable-next-line no-await-in-loop
+      const [localBuffer, remoteRes, blobResult] = await Promise.all([
+        fse.readFile(localPath),
+        client.getSource(org, repo, daPath),
+        git.readBlob({
+          fs, dir: contentDir, oid: headCommit.oid, filepath: relPath,
+        })
+          .catch(() => null),
+      ]);
+
+      const localText = localBuffer.toString('utf-8');
+      // eslint-disable-next-line no-await-in-loop
+      const remoteText = remoteRes ? await remoteRes.text() : '';
+      const baseText = blobResult ? Buffer.from(blobResult.blob).toString('utf-8') : '';
+
+      const { text: merged, conflict } = threeWayMerge(baseText, localText, remoteText);
+
+      // eslint-disable-next-line no-await-in-loop
+      await fse.writeFile(localPath, merged, 'utf-8');
+
+      if (conflict) {
+        log.info(`CONFLICT ${daPath}`);
+        conflictCount += 1;
+      } else {
+        log.info(`merged  ${daPath}`);
+        cleanCount += 1;
+      }
+    }
+
+    log.info('');
+    if (conflictCount > 0) {
+      log.info(`Merge complete: ${cleanCount} clean, ${conflictCount} with conflicts.`);
+      log.info('Resolve conflicts manually, then: aem content add, aem content commit -m "...", aem content push');
+    } else {
+      log.info(`Merge complete: ${cleanCount} file(s) merged cleanly.`);
+      log.info('Review changes, then: aem content add, aem content commit -m "...", aem content push');
+    }
+  }
+}

package/src/content/merge.js

@@ -0,0 +1,45 @@
+/*
+ * 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 { getOrCreateLogger } from '../log-common.js';
+
+export default function mergeCmd() {
+  let executor;
+  return {
+    set executor(value) {
+      executor = value;
+    },
+    command: 'merge [path]',
+    description: 'Merge remote content into local files',
+    builder: (yargs) => {
+      yargs
+        .positional('path', {
+          describe: 'File to merge (e.g. /blog/post.html). Merges all modified files if omitted.',
+          type: 'string',
+        })
+        .option('token', {
+          describe: 'IMS Bearer token for da.live authentication',
+          type: 'string',
+        })
+        .help();
+    },
+    handler: async (argv) => {
+      if (!executor) {
+        const MergeCommand = (await import('./merge.cmd.js')).default;
+        executor = new MergeCommand(getOrCreateLogger(argv));
+      }
+      await executor
+        .withToken(argv.token)
+        .withFilePath(argv.path)
+        .run();
+    },
+  };
+}

package/src/content/push.cmd.js

@@ -0,0 +1,291 @@
+/*
+ * 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 fs from 'fs';
+import path from 'path';
+import fse from 'fs-extra';
+import git from 'isomorphic-git';
+import processQueue from '@adobe/helix-shared-process-queue';
+import { DaClient, getContentType } from './da-api.js';
+import { getValidToken } from './da-auth.js';
+import {
+  CONTENT_DIR,
+  CONFIG_FILE,
+  CONTENT_IO_CONCURRENCY,
+} from './content-shared.js';
+import {
+  resolveSyncedOid,
+  writeSyncedRef,
+  statusMatrixHasUncommitted,
+  diffCommitTrees,
+  getCommitCommitterTimeMs,
+} from './content-git.js';
+
+export default class PushCommand {
+  constructor(logger) {
+    this.log = logger;
+    this._dir = process.cwd();
+    this._force = false;
+    this._dryRun = false;
+    this._pushPath = null;
+  }
+
+  withDirectory(dir) {
+    this._dir = dir;
+    return this;
+  }
+
+  withToken(token) {
+    this._token = token;
+    return this;
+  }
+
+  withForce(force) {
+    this._force = force;
+    return this;
+  }
+
+  withDryRun(dryRun) {
+    this._dryRun = dryRun;
+    return this;
+  }
+
+  withPath(pushPath) {
+    this._pushPath = pushPath || null;
+    return this;
+  }
+
+  /**
+   * Checks for conflicts between local changes and remote modifications.
+   * @param {DaClient} client
+   * @param {string} org
+   * @param {string} repo
+   * @param {string[]} modified
+   * @param {string[]} deleted
+   * @param {number} lastSyncTime
+   * @returns {Promise<boolean>} true if the push should be aborted
+   */
+  async _checkConflicts(client, org, repo, modified, deleted, lastSyncTime) {
+    const { log } = this;
+    const conflicts = [];
+
+    for (const daPath of [...modified, ...deleted]) {
+      // eslint-disable-next-line no-await-in-loop
+      const remoteLastModified = await client.getRemoteLastModified(org, repo, daPath);
+      if (remoteLastModified != null && remoteLastModified > lastSyncTime) {
+        conflicts.push({ daPath, remoteDate: new Date(remoteLastModified).toLocaleString() });
+      }
+    }
+
+    if (conflicts.length > 0) {
+      log.warn('\nConflicts detected — remote files were modified after your last sync:\n');
+      for (const { daPath, remoteDate } of conflicts) {
+        log.warn(`  ✗ ${daPath}  (remote modified ${remoteDate})`);
+      }
+      if (!this._force) {
+        log.warn('\nPush aborted. Use --force to overwrite remote changes.');
+        process.exitCode = 1;
+        return true;
+      }
+      log.warn('\n--force specified: overwriting remote changes.');
+    }
+
+    return false;
+  }
+
+  /**
+   * Uploads added and modified files to da.live.
+   * @param {DaClient} client
+   * @param {string} org
+   * @param {string} repo
+   * @param {string} contentDir
+   * @param {string[]} targets
+   * @returns {Promise<{ pushed: number, errors: number, successfullyPushed: Set<string> }>}
+   */
+  async _uploadFiles(client, org, repo, contentDir, targets) {
+    const { log } = this;
+    let pushed = 0;
+    let errors = 0;
+    const successfullyPushed = new Set();
+
+    const results = await processQueue(
+      targets,
+      async (daPath) => {
+        const localPath = path.join(contentDir, ...daPath.split('/').filter(Boolean));
+        const ext = daPath.split('.').pop();
+        try {
+          const buffer = await fse.readFile(localPath);
+          await client.putSource(org, repo, daPath, buffer, getContentType(ext));
+          log.info(`  ✓ ${daPath}`);
+          return { ok: true, daPath };
+        } catch (err) {
+          log.warn(`  ✗ ${daPath}: ${err.message}`);
+          return { ok: false };
+        }
+      },
+      CONTENT_IO_CONCURRENCY,
+    );
+    for (const r of results) {
+      if (r.ok) {
+        pushed += 1;
+        successfullyPushed.add(r.daPath);
+      } else {
+        errors += 1;
+      }
+    }
+
+    return { pushed, errors, successfullyPushed };
+  }
+
+  /**
+   * Deletes files from da.live.
+   * @param {DaClient} client
+   * @param {string} org
+   * @param {string} repo
+   * @param {string[]} deleted
+   * @returns {Promise<{ pushed: number, errors: number, successfullyDeleted: Set<string> }>}
+   */
+  async _deleteFiles(client, org, repo, deleted) {
+    const { log } = this;
+    let pushed = 0;
+    let errors = 0;
+    const successfullyDeleted = new Set();
+
+    const results = await processQueue(
+      deleted,
+      async (daPath) => {
+        try {
+          await client.deleteSource(org, repo, daPath);
+          log.info(`  ✓ deleted ${daPath}`);
+          return { ok: true, daPath };
+        } catch (err) {
+          log.warn(`  ✗ ${daPath}: ${err.message}`);
+          return { ok: false };
+        }
+      },
+      CONTENT_IO_CONCURRENCY,
+    );
+    for (const r of results) {
+      if (r.ok) {
+        pushed += 1;
+        successfullyDeleted.add(r.daPath);
+      } else {
+        errors += 1;
+      }
+    }
+
+    return { pushed, errors, successfullyDeleted };
+  }
+
+  async run() {
+    const { log } = this;
+    const contentDir = path.resolve(this._dir, CONTENT_DIR);
+    const configPath = path.join(contentDir, CONFIG_FILE);
+
+    if (!await fse.pathExists(configPath)) {
+      throw new Error(`No config found at ${configPath}. Run 'aem content clone' first.`);
+    }
+    const { org, repo } = await fse.readJson(configPath);
+
+    const matrix = await git.statusMatrix({ fs, dir: contentDir });
+    if (statusMatrixHasUncommitted(matrix)) {
+      throw new Error(
+        'Cannot push: you have uncommitted changes in content/. '
+        + 'Stage with \'aem content add\' and commit with \'aem content commit -m "..."\'.',
+      );
+    }
+
+    const headOid = await git.resolveRef({ fs, dir: contentDir, ref: 'HEAD' });
+    const syncedOid = await resolveSyncedOid(fs, contentDir);
+    const lastSyncTime = await getCommitCommitterTimeMs(fs, contentDir, syncedOid);
+
+    let { added, modified, deleted } = await diffCommitTrees(fs, contentDir, syncedOid, headOid);
+
+    const inScope = (daPath) => !this._pushPath || daPath.startsWith(this._pushPath);
+    added = added.filter(inScope);
+    modified = modified.filter(inScope);
+    deleted = deleted.filter(inScope);
+
+    if (added.length === 0 && modified.length === 0 && deleted.length === 0) {
+      log.info('Nothing to push. No commits ahead of the last da.live sync.');
+      return;
+    }
+
+    const token = await getValidToken(log, this._token, this._dir);
+
+    log.info(`Pushing content to da.live: ${org}/${repo}`);
+    log.info(`${added.length} added, ${modified.length} modified, ${deleted.length} deleted`);
+
+    const client = new DaClient(token);
+
+    const shouldAbort = await this._checkConflicts(
+      client,
+      org,
+      repo,
+      modified,
+      deleted,
+      lastSyncTime,
+    );
+    if (shouldAbort) {
+      return;
+    }
+
+    if (this._dryRun) {
+      log.info('\nDry run — no files were pushed.');
+      if (added.length) {
+        log.info('\nWould add:');
+        for (const p of added) {
+          log.info(`  + ${p}`);
+        }
+      }
+      if (modified.length) {
+        log.info('\nWould update:');
+        for (const p of modified) {
+          log.info(`  ~ ${p}`);
+        }
+      }
+      if (deleted.length) {
+        log.info('\nWould delete:');
+        for (const p of deleted) {
+          log.info(`  - ${p}`);
+        }
+      }
+      return;
+    }
+
+    const putTargets = [...added, ...modified];
+    const {
+      pushed: putPushed,
+      errors: putErrors,
+      successfullyPushed,
+    } = await this._uploadFiles(client, org, repo, contentDir, putTargets);
+
+    const {
+      pushed: deletePushed,
+      errors: deleteErrors,
+      successfullyDeleted,
+    } = await this._deleteFiles(client, org, repo, deleted);
+
+    const pushed = putPushed + deletePushed;
+    const pushErrors = putErrors + deleteErrors;
+
+    const allPutsOk = putTargets.every((p) => successfullyPushed.has(p));
+    const allDeletesOk = deleted.every((p) => successfullyDeleted.has(p));
+
+    if (allPutsOk && allDeletesOk) {
+      await writeSyncedRef(fs, contentDir, headOid);
+    } else {
+      log.warn('\nSync ref not updated: fix errors and push again to finish syncing this commit.');
+    }
+
+    log.info(`\nDone. ${pushed} file(s) pushed${pushErrors > 0 ? `, ${pushErrors} error(s)` : ''}.`);
+  }
+}

package/src/content/push.js

@@ -0,0 +1,58 @@
+/*
+ * 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 { getOrCreateLogger } from '../log-common.js';
+
+export default function push() {
+  let executor;
+  return {
+    set executor(value) {
+      executor = value;
+    },
+    command: 'push',
+    description: 'Push committed content/ changes to da.live (use content add & content commit first)',
+    builder: (yargs) => {
+      yargs
+        .option('token', {
+          describe: 'IMS Bearer token for da.live authentication',
+          type: 'string',
+        })
+        .option('path', {
+          describe: 'Push only a specific file or subtree (e.g. /blog)',
+          type: 'string',
+        })
+        .option('force', {
+          describe: 'Overwrite remote changes even when conflicts are detected',
+          type: 'boolean',
+          default: false,
+        })
+        .option('dry-run', {
+          alias: 'dryRun',
+          describe: 'Show what would be pushed without actually pushing',
+          type: 'boolean',
+          default: false,
+        })
+        .help();
+    },
+    handler: async (argv) => {
+      if (!executor) {
+        const PushCommand = (await import('./push.cmd.js')).default;
+        executor = new PushCommand(getOrCreateLogger(argv));
+      }
+      await executor
+        .withToken(argv.token)
+        .withPath(argv.path)
+        .withForce(argv.force)
+        .withDryRun(argv.dryRun)
+        .run();
+    },
+  };
+}

package/src/content/status.cmd.js

@@ -0,0 +1,94 @@
+/*
+ * 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 fs from 'fs';
+import path from 'path';
+import fse from 'fs-extra';
+import git from 'isomorphic-git';
+import { CONTENT_DIR, CONFIG_FILE } from './content-shared.js';
+import { resolveSyncedOid, countCommitsAhead } from './content-git.js';
+
+export default class StatusCommand {
+  constructor(logger) {
+    this.log = logger;
+    this._dir = process.cwd();
+  }
+
+  withDirectory(dir) {
+    this._dir = dir;
+    return this;
+  }
+
+  async run() {
+    const { log } = this;
+    const contentDir = path.resolve(this._dir, CONTENT_DIR);
+    const configPath = path.join(contentDir, CONFIG_FILE);
+
+    if (!await fse.pathExists(configPath)) {
+      throw new Error('No config found. Run \'aem content clone\' first.');
+    }
+    const { org, repo } = await fse.readJson(configPath);
+
+    log.info(`On da.live: ${org}/${repo}`);
+    log.info(`Local content: ./${CONTENT_DIR}/\n`);
+
+    const matrix = await git.statusMatrix({ fs, dir: contentDir });
+
+    const added = [];
+    const modified = [];
+    const deleted = [];
+
+    for (const [filepath, head, workdir] of matrix) {
+      if (head === 0 && workdir === 2) {
+        added.push(filepath);
+      } else if (head === 1 && workdir === 2) {
+        modified.push(filepath);
+      } else if (head === 1 && workdir === 0) {
+        deleted.push(filepath);
+      }
+    }
+
+    const headOid = await git.resolveRef({ fs, dir: contentDir, ref: 'HEAD' });
+    const syncedOid = await resolveSyncedOid(fs, contentDir);
+    const ahead = await countCommitsAhead(fs, contentDir, headOid, syncedOid);
+
+    if (added.length === 0 && modified.length === 0 && deleted.length === 0) {
+      log.info('No uncommitted changes in content/.');
+      if (ahead === 0) {
+        log.info('Nothing to push to da.live.');
+      } else {
+        log.info(`${ahead} commit(s) not yet pushed to da.live. Run 'aem content push'.`);
+      }
+      return;
+    }
+
+    if (added.length) {
+      log.info('Added (unstaged or not committed):');
+      for (const f of added) {
+        log.info(`  A  /${f}`);
+      }
+    }
+    if (modified.length) {
+      log.info('Modified (unstaged or not committed):');
+      for (const f of modified) {
+        log.info(`  M  /${f}`);
+      }
+    }
+    if (deleted.length) {
+      log.info('Deleted (unstaged or not committed):');
+      for (const f of deleted) {
+        log.info(`  D  /${f}`);
+      }
+    }
+
+    log.info(`\n${added.length} added, ${modified.length} modified, ${deleted.length} deleted`);
+  }
+}

package/src/content/status.js

@@ -0,0 +1,33 @@
+/*
+ * 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 { getOrCreateLogger } from '../log-common.js';
+
+export default function status() {
+  let executor;
+  return {
+    set executor(value) {
+      executor = value;
+    },
+    command: 'status',
+    description: 'Show locally added, modified, and deleted content files',
+    builder: (yargs) => {
+      yargs.help();
+    },
+    handler: async (argv) => {
+      if (!executor) {
+        const StatusCommand = (await import('./status.cmd.js')).default;
+        executor = new StatusCommand(getOrCreateLogger(argv));
+      }
+      await executor.run();
+    },
+  };
+}

package/src/server/BaseServer.js

@@ -10,10 +10,13 @@
  * governing permissions and limitations under the License.
  */
 import https from 'https';
+import { existsSync } from 'fs';
+import path from 'path';
 import EventEmitter from 'events';
 import express from 'express';
 import cookieParser from 'cookie-parser';
 import { getFetch } from '../fetch-utils.js';
+import { CONTENT_DIR } from '../content/content-shared.js';
 import utils from './utils.js';
 import packageJson from '../package.cjs';
 
@@ -155,7 +158,12 @@ export class BaseServer extends EventEmitter {
         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}`);
+          const contentDir = path.join(this._project.directory, CONTENT_DIR);
+          if (existsSync(contentDir)) {
+            log.info(`Serving content from local ${CONTENT_DIR}/, proxying missing files from ${this._project.proxyUrl}`);
+          } else {
+            log.info(`Enabled reverse proxy to ${this._project.proxyUrl}`);
+          }
         }
         this._server.on('connection', (socket) => {
           log.debug(`new connection from ${socket.remoteAddress}:${socket.remotePort}`);