ghost 6.54.1 → 6.56.0

package/core/server/services/gifts/gift.ts

@@ -1,7 +1,7 @@
 import {GIFT_EXPIRY_DAYS} from './constants';
+import type {GiftCadence, GiftData, GiftStatus} from './gift-schema';
 
-export type GiftStatus = 'purchased' | 'redeemed' | 'consumed' | 'expired' | 'refunded';
-export type GiftCadence = 'month' | 'year';
+export type {GiftCadence, GiftStatus} from './gift-schema';
 
 export type RedeemableCheckFailureReason = 'redeemed' | 'consumed' | 'expired' | 'refunded' | 'paid-member';
 export type RedeemableCheckResult =
@@ -13,43 +13,20 @@ export type ReassignableCheckResult =
     | {reassignable: true}
     | {reassignable: false; reason: ReassignableCheckFailureReason};
 
-interface GiftData {
-    token: string;
-    buyerEmail: string;
-    buyerMemberId: string | null;
-    redeemerMemberId: string | null;
-    tierId: string;
-    cadence: GiftCadence;
-    duration: number;
-    currency: string;
-    amount: number;
-    stripeCheckoutSessionId: string;
-    stripePaymentIntentId: string;
-    consumesAt: Date | null;
-    expiresAt: Date;
-    status: GiftStatus;
-    purchasedAt: Date;
-    redeemedAt: Date | null;
-    consumedAt: Date | null;
-    expiredAt: Date | null;
-    refundedAt: Date | null;
-    consumesSoonReminderSentAt: Date | null;
-}
-
-export interface GiftFromPurchaseData {
-    token: string;
-    buyerEmail: string;
-    buyerMemberId: string | null;
-    tierId: string;
-    cadence: GiftCadence;
-    duration: number;
-    currency: string;
-    amount: number;
-    stripeCheckoutSessionId: string;
-    stripePaymentIntentId: string;
-}
-
-export class Gift {
+export type GiftFromPurchaseData = Pick<GiftData,
+    | 'token'
+    | 'buyerEmail'
+    | 'buyerMemberId'
+    | 'tierId'
+    | 'cadence'
+    | 'duration'
+    | 'currency'
+    | 'amount'
+    | 'stripeCheckoutSessionId'
+    | 'stripePaymentIntentId'
+>;
+
+export class Gift implements GiftData {
     token: string;
     buyerEmail: string;
     buyerMemberId: string | null;

package/core/server/services/lib/dynamic-redirect-manager.js

@@ -56,14 +56,23 @@ class DynamicRedirectManager {
 
         this.router.get(fromRegex, (req, res) => {
             const maxAge = permanent ? this.permanentMaxAge : 0;
-            const toURL = parseURL(to);
-            const toURLParams = parseQuerystring(toURL.query);
             const currentURL = parseURL(req.url);
             const currentURLParams = parseQuerystring(currentURL.query);
+
+            const toURL = parseURL(to);
+            toURL.pathname = currentURL.pathname.replace(fromRegex, toURL.pathname);
+
+            // Captures are percent-encoded path segments (Express rejects any it can't decode),
+            // so decode then re-encode for the query — reserved chars stay literal, no double-encoding
+            const captures = currentURL.pathname.match(fromRegex) || [];
+            const substitutedQuery = (toURL.query || '').replace(/\$(\d+)/g, (match, n) => (
+                captures[n] !== undefined ? encodeURIComponent(decodeURIComponent(captures[n])) : match
+            ));
+            const toURLParams = parseQuerystring(substitutedQuery);
+
             const params = Object.assign({}, currentURLParams, toURLParams);
             const search = formatQuerystring(params);
 
-            toURL.pathname = currentURL.pathname.replace(fromRegex, toURL.pathname);
             toURL.search = search !== '' ? `?${search}` : null;
 
             /**

package/core/server/services/link-redirection/link-redirect-repository.js

@@ -1,3 +1,4 @@
+const crypto = require('crypto');
 const {LinkRedirect} = require('./link-redirect');
 const ObjectID = require('bson-objectid').default;
 const debug = require('@tryghost/debug')('LinkRedirectRepository');
@@ -49,7 +50,11 @@ module.exports = class LinkRedirectRepository {
         const model = await this.#LinkRedirect.add({
             // Only store the pathname (no support for variable query strings)
             from: this.stripSubdirectoryFromPath(linkRedirect.from.pathname),
-            to: linkRedirect.to.href
+            to: linkRedirect.to.href,
+            ...(linkRedirect.automationActionRevisionId ? {
+                automation_action_revision_id: linkRedirect.automationActionRevisionId,
+                to_hash: this.#getToHash(linkRedirect.to)
+            } : {})
         }, {});
 
         linkRedirect.link_id = ObjectID.createFromHexString(model.id);
@@ -82,7 +87,8 @@ module.exports = class LinkRedirectRepository {
             id: model.id,
             from: new URL(this.#trimLeadingSlash(model.get('from')), this.#urlUtils.urlFor('home', true)),
             to: new URL(model.get('to')),
-            edited
+            edited,
+            automationActionRevisionId: model.get('automation_action_revision_id')
         });
     }
 
@@ -93,6 +99,7 @@ module.exports = class LinkRedirectRepository {
      * @param {string} serialized.from - path of the URL
      * @param {string} serialized.to - URL to redirect to
      * @param {boolean} serialized.edited - whether the link has been edited
+     * @param {string} [serialized.automationActionRevisionId] - owning automation action revision
      * @returns {InstanceType<LinkRedirect>} LinkRedirect
      */
     #fromSerialized(serialized) {
@@ -100,7 +107,8 @@ module.exports = class LinkRedirectRepository {
             id: serialized.link_id,
             from: new URL(this.#trimLeadingSlash(serialized.from), this.#urlUtils.urlFor('home', true)),
             to: new URL(serialized.to),
-            edited: serialized.edited
+            edited: serialized.edited,
+            automationActionRevisionId: serialized.automationActionRevisionId
         });
     }
 
@@ -114,7 +122,10 @@ module.exports = class LinkRedirectRepository {
             link_id: linkRedirect.link_id.toHexString(),
             from: linkRedirect.from.pathname,
             to: linkRedirect.to.href,
-            edited: linkRedirect.edited
+            edited: linkRedirect.edited,
+            ...(linkRedirect.automationActionRevisionId ? {
+                automationActionRevisionId: linkRedirect.automationActionRevisionId
+            } : {})
         };
     }
 
@@ -180,6 +191,32 @@ module.exports = class LinkRedirectRepository {
         }
     }
 
+    /**
+     * Get an automation LinkRedirect by action revision and destination URL
+     * @param {string} automationActionRevisionId
+     * @param {Readonly<URL>} url
+     * @returns {Promise<InstanceType<LinkRedirect>|undefined>} LinkRedirect
+     */
+    async getByAutomationActionRevisionAndURL(automationActionRevisionId, url) {
+        const linkRedirectModel = await this.#LinkRedirect.findOne({
+            automation_action_revision_id: automationActionRevisionId,
+            to_hash: this.#getToHash(url)
+        }, {});
+
+        if (linkRedirectModel) {
+            return this.fromModel(linkRedirectModel);
+        }
+    }
+
+    /**
+     * The destination column is too long to index, so unique lookups use its SHA-256 digest
+     * @param {Readonly<URL>} url
+     * @returns {Buffer}
+     */
+    #getToHash(url) {
+        return crypto.createHash('sha256').update(url.href).digest();
+    }
+
     /**
      * Convert root relative URLs to subdirectory relative URLs
      * @param {string} path

package/core/server/services/link-redirection/link-redirect.js

@@ -10,6 +10,7 @@ class LinkRedirect {
     from;
     to;
     edited;
+    automationActionRevisionId;
     constructor(data) {
         if (!data.id) {
             this.link_id = new bson_objectid_1.default();
@@ -20,6 +21,7 @@ class LinkRedirect {
         this.from = data.from;
         this.to = data.to;
         this.edited = !!data.edited;
+        this.automationActionRevisionId = data.automationActionRevisionId ?? undefined;
     }
 }
 exports.LinkRedirect = LinkRedirect;

package/core/server/services/link-redirection/link-redirect.ts

@@ -5,8 +5,9 @@ export class LinkRedirect {
     from: URL;
     to: URL;
     edited: boolean;
+    automationActionRevisionId: string | undefined;
 
-    constructor(data: {id?: string; from: URL; to: URL; edited?: boolean}) {
+    constructor(data: {id?: string; from: URL; to: URL; edited?: boolean; automationActionRevisionId?: string | null}) {
         if (!data.id) {
             this.link_id = new ObjectID();
         }
@@ -18,5 +19,6 @@ export class LinkRedirect {
         this.from = data.from;
         this.to = data.to;
         this.edited = !!data.edited;
+        this.automationActionRevisionId = data.automationActionRevisionId ?? undefined;
     }
 }

package/core/server/services/link-redirection/link-redirects-service.js

@@ -6,6 +6,7 @@ const {LinkRedirect} = require('./link-redirect');
 /**
  * @typedef {object} ILinkRedirectRepository
  * @prop {(url: URL) => Promise<LinkRedirect|undefined>} getByURL
+ * @prop {(automationActionRevisionId: string, url: URL) => Promise<LinkRedirect|undefined>} getByAutomationActionRevisionAndURL
  * @prop {({filter: string}) => Promise<LinkRedirect[]>} getAll
  * @prop {({filter: string}) => Promise<String[]>} getFilteredIds
  * @prop {(linkRedirect: LinkRedirect) => Promise<void>} save
@@ -19,6 +20,8 @@ const MEMBER_UUID_PLACEHOLDER = '%%{uuid}%%';
 //   Ghost uses UUID v4; this regex is not that strict
 const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
+const isUniqueConstraintError = err => err?.code === 'ER_DUP_ENTRY' || err?.code?.startsWith?.('SQLITE_CONSTRAINT');
+
 class LinkRedirectsService {
     /** @type ILinkRedirectRepository */
     #linkRedirectRepository;
@@ -71,13 +74,15 @@ class LinkRedirectsService {
     /**
      * @param {URL} from
      * @param {URL} to
+     * @param {string} [automationActionRevisionId]
      *
      * @returns {Promise<LinkRedirect>}
      */
-    async addRedirect(from, to) {
+    async addRedirect(from, to, automationActionRevisionId) {
         const link = new LinkRedirect({
             from,
-            to
+            to,
+            automationActionRevisionId
         });
 
         await this.#linkRedirectRepository.save(link);
@@ -85,6 +90,37 @@ class LinkRedirectsService {
         return link;
     }
 
+    /**
+     * Get the shared redirect for a destination within an automation action revision,
+     * creating it on first use. A concurrent winning insert is returned after a
+     * duplicate-key failure.
+     * @param {string} automationActionRevisionId
+     * @param {Readonly<URL>} to
+     * @returns {Promise<LinkRedirect>}
+     */
+    async getOrAddAutomationRedirect(automationActionRevisionId, to) {
+        const existing = await this.#linkRedirectRepository.getByAutomationActionRevisionAndURL(automationActionRevisionId, to);
+        if (existing) {
+            return existing;
+        }
+
+        const from = await this.getSlugUrl();
+        try {
+            return await this.addRedirect(from, to, automationActionRevisionId);
+        } catch (err) {
+            if (!isUniqueConstraintError(err)) {
+                throw err;
+            }
+
+            const winner = await this.#linkRedirectRepository.getByAutomationActionRevisionAndURL(automationActionRevisionId, to);
+            if (winner) {
+                return winner;
+            }
+
+            throw err;
+        }
+    }
+
     /**
      * Returns the relative path prefix without subdirectory (e.g., /r/)
      * Used for Express route matching where subdirectory is already stripped

package/core/server/services/link-tracking/click-event.js

@@ -7,6 +7,8 @@ module.exports = class ClickEvent {
     member_uuid;
     /** @type {ObjectID} */
     link_id;
+    /** @type {Date | undefined} */
+    timestamp;
 
     constructor(data) {
         if (!data.id) {
@@ -21,5 +23,6 @@ module.exports = class ClickEvent {
 
         this.member_uuid = data.member_uuid;
         this.link_id = data.link_id;
+        this.timestamp = data.timestamp;
     }
 };

package/core/server/services/link-tracking/index.js

@@ -4,12 +4,37 @@ const errors = require('@tryghost/errors');
 const urlUtils = require('../../../shared/url-utils').default;
 
 class LinkTrackingServiceWrapper {
+    #initPromise;
+    #automationsApi;
+
+    constructor({
+        automationsApi = require('../automations/automations-api')
+    } = {}) {
+        this.#automationsApi = automationsApi;
+    }
+
     async init() {
         if (this.service) {
             // Already done
             return;
         }
 
+        if (!this.#initPromise) {
+            this.#initPromise = this.#initialise();
+        }
+
+        const initPromise = this.#initPromise;
+        try {
+            await initPromise;
+        } catch (error) {
+            if (this.#initPromise === initPromise) {
+                this.#initPromise = undefined;
+            }
+            throw error;
+        }
+    }
+
+    async #initialise() {
         const linkRedirection = require('../link-redirection');
         if (!linkRedirection.service) {
             throw new errors.InternalServerError({message: 'LinkRedirectionService should be initialised before LinkTrackingService'});
@@ -27,24 +52,31 @@ class LinkTrackingServiceWrapper {
             linkRedirectRepository: linkRedirection.linkRedirectRepository
         });
 
-        this.linkClickRepository = new LinkClickRepository({
+        const linkClickRepository = new LinkClickRepository({
             MemberLinkClickEventModel: models.MemberClickEvent,
             Member: models.Member,
             MemberLinkClickEvent: MemberLinkClickEvent,
             DomainEvents
         });
 
-        // Expose the service
-        this.service = new LinkClickTrackingService({
+        const service = new LinkClickTrackingService({
             linkRedirectService: linkRedirection.service,
-            linkClickRepository: this.linkClickRepository,
+            linkClickRepository,
             postLinkRepository,
             DomainEvents,
-            urlUtils
+            urlUtils,
+            automationsApi: this.#automationsApi,
+            runInTransaction: callback => models.Base.transaction(callback)
         });
 
-        await this.service.init();
+        await service.init();
+
+        // Expose the service only after it has finished initialising
+        this.linkClickRepository = linkClickRepository;
+        this.service = service;
     }
 }
 
 module.exports = new LinkTrackingServiceWrapper();
+// Exposed for testing purposes only
+module.exports.LinkTrackingServiceWrapper = LinkTrackingServiceWrapper;

package/core/server/services/link-tracking/link-click-repository.js

@@ -31,8 +31,13 @@ module.exports = class LinkClickRepository {
         this.#DomainEvents = deps.DomainEvents;
 
         // Memoize the findOne function
-        this.memoizedFindOne = _.memoize(async (uuid) => {
-            return await this.#Member.findOne({uuid});
+        this.memoizedFindOne = _.memoize(async (uuid, options) => {
+            try {
+                return await this.#Member.findOne({uuid}, options);
+            } catch (error) {
+                this.memoizedFindOne.cache.delete(uuid);
+                throw error;
+            }
         });
     }
 
@@ -54,15 +59,18 @@ module.exports = class LinkClickRepository {
 
     /**
      * @param {LinkClick} linkClick
-     * @returns {Promise<void>}
+     * @param {object} [options]
+     * @param {object} [options.transacting]
+     * @returns {Promise<string | undefined>}
      */
-    async save(linkClick) {
+    async save(linkClick, options = {}) {
         let member;
+        const memberLookupOptions = options.transacting ? {transacting: options.transacting} : undefined;
 
         if (config && config.get('linkClickTrackingCacheMemberUuid')) {
-            member = await this.memoizedFindOne(linkClick.member_uuid);
+            member = await this.memoizedFindOne(linkClick.member_uuid, memberLookupOptions);
         } else {
-            member = await this.#Member.findOne({uuid: linkClick.member_uuid});
+            member = await this.#Member.findOne({uuid: linkClick.member_uuid}, memberLookupOptions);
         }
 
         if (!member) {
@@ -76,11 +84,29 @@ module.exports = class LinkClickRepository {
             // Only store the pathname (no support for variable query strings)
             redirect_id: linkClick.link_id.toHexString(),
             member_id: member.id
-        }, {});
+        }, options);
 
         linkClick.event_id = ObjectID.createFromHexString(model.id);
+        const timestamp = linkClick.timestamp ?? new Date();
+
+        const event = this.#MemberLinkClickEvent.create({
+            memberId: member.id,
+            memberLastSeenAt: member.get('last_seen_at'),
+            linkId: linkClick.link_id.toHexString()
+        }, timestamp);
+
+        if (options.transacting) {
+            options.transacting.executionPromise.then(() => {
+                try {
+                    this.#DomainEvents.dispatch(event);
+                } catch (error) {
+                    sentry.captureException(error);
+                }
+            }, () => undefined);
+        } else {
+            this.#DomainEvents.dispatch(event);
+        }
 
-        // Dispatch event
-        this.#DomainEvents.dispatch(this.#MemberLinkClickEvent.create({memberId: member.id, memberLastSeenAt: member.get('last_seen_at'), linkId: linkClick.link_id.toHexString()}, new Date()));
+        return member.id;
     }
 };

package/core/server/services/link-tracking/link-click-tracking-service.js

@@ -4,13 +4,14 @@ const PostLink = require('./post-link');
 const ObjectID = require('bson-objectid').default;
 const errors = require('@tryghost/errors');
 const nql = require('@tryghost/nql');
+const {escapeNqlString} = require('@tryghost/nql-string');
 const _ = require('lodash');
 const tpl = require('@tryghost/tpl');
 const moment = require('moment');
 
 /**
  * @typedef {object} ILinkClickRepository
- * @prop {(event: LinkClick) => Promise<void>} save
+ * @prop {(event: LinkClick, options?: {transacting?: object}) => Promise<string | undefined>} save
  * @prop {({filter: string}) => Promise<LinkClick[]>} getAll
  */
 
@@ -61,6 +62,10 @@ class LinkClickTrackingService {
     #LinkRedirect;
     /** @type {Object} */
     #urlUtils;
+    /** @type {object} */
+    #automationsApi;
+    /** @type {(callback: (transacting: object) => Promise<void>) => Promise<void>} */
+    #runInTransaction;
 
     /**
      * @param {object} deps
@@ -69,6 +74,8 @@ class LinkClickTrackingService {
      * @param {IPostLinkRepository} deps.postLinkRepository
      * @param {DomainEvents} deps.DomainEvents
      * @param {urlUtils} deps.urlUtils
+     * @param {object} deps.automationsApi
+     * @param {(callback: (transacting: object) => Promise<void>) => Promise<void>} deps.runInTransaction
      */
     constructor(deps) {
         this.#linkClickRepository = deps.linkClickRepository;
@@ -76,6 +83,8 @@ class LinkClickTrackingService {
         this.#postLinkRepository = deps.postLinkRepository;
         this.#DomainEvents = deps.DomainEvents;
         this.#urlUtils = deps.urlUtils;
+        this.#automationsApi = deps.automationsApi;
+        this.#runInTransaction = deps.runInTransaction;
     }
 
     async init() {
@@ -166,7 +175,11 @@ class LinkClickTrackingService {
 
         // manages transformation of current url to relative for comparision
         const transformedOldUrl = this.#urlUtils.absoluteToTransformReady(redirectUrl.href);
-        const filterQuery = `post_id:'${postId}'+to:'${transformedOldUrl}'`;
+        // the url is re-serialised into NQL here, so it needs escaping again -
+        // quotes are legal in a URL and would otherwise break the filter.
+        // postId is String()d because nql parses an unquoted `post_id:123` to a
+        // number, and escapeNqlString operates on strings
+        const filterQuery = `post_id:${escapeNqlString(String(postId))}+to:${escapeNqlString(transformedOldUrl)}`;
 
         const updatedFilterOptions = {
             ...filterOptions,
@@ -233,6 +246,22 @@ class LinkClickTrackingService {
         return url;
     }
 
+    /**
+     * Add first-party tracking to a URL in an automation email
+     * @param {Readonly<URL>} url
+     * @param {string} automationActionRevisionId
+     * @param {string} automationRunStepId
+     * @param {string} memberUuid
+     * @return {Promise<URL>}
+     */
+    async addAutomationTrackingToUrl(url, automationActionRevisionId, automationRunStepId, memberUuid) {
+        const redirect = await this.#linkRedirectService.getOrAddAutomationRedirect(automationActionRevisionId, url);
+        const trackedUrl = new URL(redirect.from.href);
+        trackedUrl.searchParams.set('m', memberUuid);
+        trackedUrl.searchParams.set('step', automationRunStepId);
+        return trackedUrl;
+    }
+
     subscribe() {
         this.#DomainEvents.subscribe(RedirectEvent, async (event) => {
             const uuid = event.data.url.searchParams.get('m');
@@ -242,9 +271,30 @@ class LinkClickTrackingService {
 
             const click = new LinkClick({
                 member_uuid: uuid,
-                link_id: event.data.link.link_id
+                link_id: event.data.link.link_id,
+                timestamp: event.timestamp
+            });
+
+            const automationActionRevisionId = event.data.link.automationActionRevisionId;
+            const automationRunStepId = event.data.url.searchParams.get('step');
+            if (!automationActionRevisionId || !automationRunStepId) {
+                await this.#linkClickRepository.save(click);
+                return;
+            }
+
+            await this.#runInTransaction(async (transacting) => {
+                const memberId = await this.#linkClickRepository.save(click, {transacting});
+                if (!memberId) {
+                    return;
+                }
+
+                await this.#automationsApi.trackEmailClicked({
+                    automationActionRevisionId,
+                    automationRunStepId,
+                    memberId,
+                    clickedAt: event.timestamp
+                }, {transacting});
             });
-            await this.#linkClickRepository.save(click);
         });
     }
 }

package/core/server/services/member-attribution/outbound-link-tagger.js

@@ -11,7 +11,9 @@ const blockedReferrerDomains = [
     'www.chicagomag.com',
     'bailii.org',
     'www.bailii.org',
-    '*.doubleclick.net'
+    '*.doubleclick.net',
+    // Substack's client app throws on any non-empty ?ref= value and swaps the post for an error screen
+    '*.substack.com'
 ];
 
 const isBlockedReferrerDomain = (domain) => {

package/core/server/services/member-welcome-emails/member-welcome-email-renderer.js

@@ -2,11 +2,13 @@ const fs = require('fs');
 const path = require('path');
 const lexicalLib = require('../../lib/lexical');
 const labs = require('../../../shared/labs');
+const urlUtils = require('../../../shared/url-utils').default;
 const {finalize} = require('../email-rendering/finalize');
 const errors = require('@tryghost/errors');
 const {MESSAGES} = require('./constants');
 const {wrapReplacementStrings} = require('@tryghost/kg-default-nodes').utils.replacementStrings;
 const linkReplacer = require('../lib/link-replacer');
+const linkTracking = require('../link-tracking');
 const emailDesign = require('../email-rendering/email-design');
 const {registerHelpers} = require('../email-service/helpers/register-helpers');
 
@@ -115,9 +117,12 @@ class MemberWelcomeEmailRenderer {
      * @param {Object} options.member - Member data (name, email)
      * @param {Object} options.siteSettings - Site settings (title, url, accentColor)
      * @param {string} [options.unsubscribeUrl] - When set, the footer shows an "Unsubscribe from these emails" link instead of "Manage your preferences"
+     * @param {boolean} [options.trackClicks]
+     * @param {string | null} [options.automationActionRevisionId]
+     * @param {string | null} [options.automationRunStepId]
      * @returns {Promise<{html: string, text: string, subject: string}>}
      */
-    async render({lexical, subject, designSettings, member, siteSettings, unsubscribeUrl}) {
+    async render({lexical, subject, designSettings, member, siteSettings, unsubscribeUrl, trackClicks = false, automationActionRevisionId = null, automationRunStepId = null}) {
         designSettings = designSettings || {};
 
         const design = emailDesign.getEmailDesign({
@@ -138,7 +143,8 @@ class MemberWelcomeEmailRenderer {
 
         let content;
         try {
-            content = await lexicalLib.render(lexical, {target: 'email', design});
+            const absoluteLexical = urlUtils.transformReadyToAbsolute(lexical);
+            content = await lexicalLib.render(absoluteLexical, {target: 'email', design});
         } catch (err) {
             throw new errors.IncorrectUsageError({
                 message: MESSAGES.INVALID_LEXICAL_STRUCTURE,
@@ -158,8 +164,18 @@ class MemberWelcomeEmailRenderer {
         const contentWithReplacements = this.#applyReplacements({definitions, text: content, escapeHtml: true});
         const subjectWithReplacements = this.#applyReplacements({definitions, text: subject, escapeHtml: false});
 
-        // Resolve relative links (e.g. #/portal/signup) to absolute URLs using the site URL
-        const contentWithAbsoluteLinks = await linkReplacer.replace(contentWithReplacements, (url) => {
+        // Resolve relative links, including Ghost Portal routes such as #/portal/signup,
+        // while preserving document-local anchors such as #section.
+        const contentWithAbsoluteLinks = await linkReplacer.replace(contentWithReplacements, async (url, originalPath) => {
+            const isDocumentAnchor = originalPath.startsWith('#') && !originalPath.startsWith('#/');
+            if (isDocumentAnchor) {
+                return originalPath;
+            }
+            const isTrackable = ['http:', 'https:'].includes(url.protocol);
+            if (trackClicks && automationActionRevisionId && automationRunStepId && member.uuid && isTrackable) {
+                await linkTracking.init();
+                return await linkTracking.service.addAutomationTrackingToUrl(url, automationActionRevisionId, automationRunStepId, member.uuid);
+            }
             return url;
         }, {base: siteSettings.url});