ghost 6.57.1 → 6.58.0

package/core/server/services/machine-payments/service.js

@@ -0,0 +1,275 @@
+"use strict";
+/**
+ * Protocol-agnostic machine payments orchestrator.
+ *
+ * Adapters implement canHandle / challenge / fulfill. Membership and content
+ * gating stay outside this service — we only authorize emitting markdown bytes.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MachinePaymentsService = exports.PAID_MARKDOWN_CACHE_CONTROL = void 0;
+exports.getDefaultTiersCurrency = getDefaultTiersCurrency;
+const logging_1 = __importDefault(require("@tryghost/logging"));
+const pricing_1 = require("./pricing");
+const eligibility_1 = require("./eligibility");
+const content_loader_1 = require("./content-loader");
+exports.PAID_MARKDOWN_CACHE_CONTROL = 'private, no-store';
+const settingsCache = require('../../../shared/settings-cache');
+const labs = require('../../../shared/labs');
+class MachinePaymentsService {
+    settingsCache;
+    labs;
+    pricing;
+    contentLoader;
+    adapters;
+    eventRepository;
+    paymentRecorder;
+    isStripeConnected;
+    defaultCurrencyProvider;
+    constructor({ settingsCache: settings = settingsCache, labsService = labs, pricing, contentLoader = new content_loader_1.ContentLoader(), adapters = [], eventRepository = null, paymentRecorder = null, isStripeConnected = () => false, defaultCurrencyProvider = getDefaultTiersCurrency } = {}) {
+        this.settingsCache = settings;
+        this.labs = labsService;
+        this.pricing = pricing || new pricing_1.Pricing({ settingsCache: settings, defaultCurrencyProvider });
+        this.contentLoader = contentLoader;
+        this.adapters = adapters;
+        this.eventRepository = eventRepository;
+        this.paymentRecorder = paymentRecorder;
+        this.isStripeConnected = isStripeConnected;
+        this.defaultCurrencyProvider = defaultCurrencyProvider;
+    }
+    isEnabled() {
+        return (0, eligibility_1.isMachinePaymentsEnabled)({
+            labs: this.labs,
+            settingsCache: this.settingsCache,
+            isStripeConnected: this.isStripeConnected
+        });
+    }
+    isPurchasable(entry) {
+        return this.isEnabled() && (0, eligibility_1.isPurchasableEntry)(entry);
+    }
+    async getTerms({ url, description, method = 'GET', mimeType = 'text/markdown' }) {
+        const { amount, currency } = await this.pricing.getTerms();
+        return {
+            amount,
+            currency,
+            description: description || safePathname(url),
+            method,
+            mimeType,
+            url
+        };
+    }
+    /**
+     * Challenge or fulfill a paid markdown request.
+     * Does not load full HTML until payment fulfills successfully.
+     */
+    async challengeOrFulfill(request, options) {
+        if (!this.isEnabled()) {
+            return this.#problemResponse({
+                type: 'https://paymentauth.org/problems/payment-unavailable',
+                title: 'Machine payments unavailable',
+                status: 404,
+                detail: 'Machine payments are not enabled.'
+            });
+        }
+        if (!this.adapters.length) {
+            return this.#problemResponse({
+                type: 'https://paymentauth.org/problems/payment-unavailable',
+                title: 'Machine payment challenges unavailable',
+                status: 503,
+                detail: 'Machine payment challenges are temporarily unavailable.'
+            });
+        }
+        // Check raw model eligibility before challenging or charging. Content API
+        // serialization strips free tiers, which would otherwise 402 a mixed post
+        // and 403 after settlement.
+        if (typeof this.contentLoader.isPurchasable === 'function') {
+            const purchasable = await this.contentLoader.isPurchasable(options.resourceType, options.entryId);
+            if (!purchasable) {
+                return this.#problemResponse({
+                    type: 'https://paymentauth.org/problems/payment-forbidden',
+                    title: 'Content unavailable',
+                    status: 403,
+                    detail: 'This content is not available for machine payment.'
+                });
+            }
+        }
+        const terms = await this.getTerms({
+            url: request.url,
+            description: options.description
+        });
+        const credentialed = this.adapters.find(adapter => adapter.canHandle(request));
+        if (credentialed) {
+            return await this.#handleFulfill(credentialed, request, terms, options);
+        }
+        return await this.#paymentRequiredResponse(request, terms);
+    }
+    async #handleFulfill(adapter, request, terms, options) {
+        // Confirm we can deliver before settling. Charging first then failing the
+        // load burns the agent’s money and (with a ledger write) their credential.
+        const entry = await this.contentLoader.loadFullEntry(options.resourceType, options.entryId);
+        if (!entry) {
+            return this.#problemResponse({
+                type: 'https://paymentauth.org/problems/payment-forbidden',
+                title: 'Content unavailable',
+                status: 403,
+                detail: 'This content is not available for machine payment.'
+            });
+        }
+        let fulfillment;
+        try {
+            fulfillment = await adapter.fulfill(request, terms);
+        }
+        catch (err) {
+            return this.#paymentCredentialErrorResponse(err);
+        }
+        // Ledger next: Stripe idempotency keys can expire (~24h), so a durable
+        // protocol+reference check must gate PaymentIntent creation on replay.
+        if (this.eventRepository) {
+            let saved;
+            try {
+                saved = await this.eventRepository.save({
+                    postId: options.entryId,
+                    amount: fulfillment.amount ?? terms.amount,
+                    currency: fulfillment.currency ?? terms.currency,
+                    protocol: fulfillment.protocol || 'mpp',
+                    method: fulfillment.method,
+                    stripePaymentIntentId: fulfillment.stripePaymentIntentId || null,
+                    reference: fulfillment.reference
+                });
+            }
+            catch (err) {
+                logging_1.default.warn(err);
+                return this.#problemResponse({
+                    type: 'https://paymentauth.org/problems/payment-unavailable',
+                    title: 'Machine payment temporarily unavailable',
+                    status: 503,
+                    detail: 'Machine payment verification is temporarily unavailable.'
+                });
+            }
+            if (saved && saved.created === false) {
+                return this.#problemResponse({
+                    type: 'https://paymentauth.org/problems/payment-forbidden',
+                    title: 'Payment credential already used',
+                    status: 403,
+                    detail: 'This machine payment credential has already been used.'
+                });
+            }
+        }
+        if (this.paymentRecorder) {
+            try {
+                const stripePaymentIntentId = await this.paymentRecorder.record({
+                    ...fulfillment,
+                    postId: options.entryId,
+                    amount: terms.amount,
+                    currency: terms.currency
+                });
+                if (stripePaymentIntentId) {
+                    fulfillment.stripePaymentIntentId = stripePaymentIntentId;
+                }
+            }
+            catch (err) {
+                logging_1.default.warn(err);
+            }
+        }
+        const body = options.renderMarkdown(entry);
+        const headers = new Headers({
+            'Content-Type': 'text/markdown; charset=utf-8',
+            'Cache-Control': exports.PAID_MARKDOWN_CACHE_CONTROL,
+            'Content-Location': options.contentLocation
+        });
+        if (fulfillment.receiptHeaders) {
+            Object.entries(fulfillment.receiptHeaders).forEach(([key, value]) => {
+                headers.set(key, value);
+            });
+        }
+        return new Response(body, { status: 200, headers });
+    }
+    async #paymentRequiredResponse(request, terms) {
+        const results = await Promise.allSettled(this.adapters.map(adapter => adapter.challenge(request, terms)));
+        const challenges = results
+            .filter((result) => result.status === 'fulfilled' && Boolean(result.value))
+            .map(result => result.value);
+        if (!challenges.length) {
+            return this.#problemResponse({
+                type: 'https://paymentauth.org/problems/payment-unavailable',
+                title: 'Machine payment challenges unavailable',
+                status: 503,
+                detail: 'Machine payment challenges are temporarily unavailable.'
+            });
+        }
+        const headers = new Headers({
+            'Cache-Control': 'no-store',
+            'Content-Type': 'application/problem+json'
+        });
+        for (const challenge of challenges) {
+            if (challenge.headers) {
+                challenge.headers.forEach((value, key) => {
+                    // Preserve every WWW-Authenticate (mpp compose can emit several)
+                    // and keep distinct payment challenge headers.
+                    if (key.toLowerCase() === 'www-authenticate') {
+                        headers.append(key, value);
+                    }
+                    else if (!headers.has(key)) {
+                        headers.set(key, value);
+                    }
+                });
+            }
+        }
+        return new Response(JSON.stringify({
+            type: 'https://paymentauth.org/problems/payment-required',
+            title: 'Payment Required',
+            status: 402,
+            detail: 'Payment is required to access this markdown content.'
+        }), {
+            status: 402,
+            headers
+        });
+    }
+    #paymentCredentialErrorResponse(err) {
+        if (err?.statusCode === 403) {
+            return this.#problemResponse({
+                type: 'https://paymentauth.org/problems/payment-forbidden',
+                title: 'Payment credential rejected',
+                status: 403,
+                detail: 'The supplied machine payment credential could not be validated.'
+            });
+        }
+        logging_1.default.warn(err);
+        return this.#problemResponse({
+            type: 'https://paymentauth.org/problems/payment-unavailable',
+            title: 'Machine payment temporarily unavailable',
+            status: 503,
+            detail: 'Machine payment verification is temporarily unavailable.'
+        });
+    }
+    #problemResponse({ type, title, status, detail }) {
+        return new Response(JSON.stringify({ type, title, status, detail }), {
+            status,
+            headers: {
+                'Cache-Control': 'no-store',
+                'Content-Type': 'application/problem+json'
+            }
+        });
+    }
+}
+exports.MachinePaymentsService = MachinePaymentsService;
+async function getDefaultTiersCurrency() {
+    const models = require('../../models');
+    const page = await models.Product.findPage({
+        filter: 'type:paid+active:true',
+        limit: 1,
+        order: 'monthly_price asc'
+    });
+    const tier = page.data?.[0]?.toJSON?.() || page.data?.[0];
+    return tier?.currency || null;
+}
+function safePathname(url) {
+    try {
+        return new URL(url).pathname;
+    }
+    catch {
+        return url;
+    }
+}

package/core/server/services/machine-payments/stripe/deposit-address-store.js

@@ -0,0 +1,157 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DepositAddressStore = exports.STRIPE_MACHINE_PAYMENTS_API_VERSION = void 0;
+exports.createStripeDepositAddressClient = createStripeDepositAddressClient;
+const errors_1 = __importDefault(require("@tryghost/errors"));
+const stripe_1 = require("stripe");
+const stripe_client_options_1 = require("./stripe-client-options");
+// Preview API required for crypto deposit addresses / machine payments.
+exports.STRIPE_MACHINE_PAYMENTS_API_VERSION = '2026-05-27.preview';
+const DEPOSIT_ADDRESS_SETTING = 'machine_payments_deposit_address';
+const settingsHelpers = require('../../settings-helpers');
+const settingsCache = require('../../../../shared/settings-cache');
+/**
+ * Build a client that can mint crypto deposit addresses on stripe@8, which
+ * lacks the typed `crypto.depositAddresses` namespace.
+ */
+function createStripeDepositAddressClient(secretKey) {
+    const stripe = new stripe_1.Stripe(secretKey, {
+        // Preview crypto APIs are not yet in the published Stripe types.
+        ...(0, stripe_client_options_1.getMachinePaymentsStripeOptions)(exports.STRIPE_MACHINE_PAYMENTS_API_VERSION)
+    });
+    const DepositAddresses = stripe_1.Stripe.StripeResource.extend({
+        path: 'crypto/deposit_addresses',
+        includeBasic: ['create']
+    });
+    const depositAddresses = new DepositAddresses(stripe);
+    return {
+        crypto: stripe.crypto,
+        createCryptoDepositAddress: params => depositAddresses.create(params)
+    };
+}
+/**
+ * Durable per-network deposit-address store.
+ * Persists a JSON map of network → address in settings so per-network deposit
+ * addresses cannot share a single chain address.
+ *
+ * Stripe's machine-payments docs recommend minting deposit addresses off the
+ * request path via POST /v1/crypto/deposit_addresses — never by confirming a
+ * PaymentIntent from an anonymous GET.
+ */
+class DepositAddressStore {
+    stripeFactory;
+    settingsHelpers;
+    settingsCache;
+    _settingsModel;
+    stripe;
+    stripeSecretKey;
+    #addresses = {};
+    #inflight = new Map();
+    constructor({ stripeFactory = createStripeDepositAddressClient, settingsHelpersFacade = settingsHelpers, settingsCacheFacade = settingsCache, settingsModel } = {}) {
+        this.stripeFactory = stripeFactory;
+        this.settingsHelpers = settingsHelpersFacade;
+        this.settingsCache = settingsCacheFacade;
+        this._settingsModel = settingsModel;
+        this.stripe = null;
+        this.stripeSecretKey = null;
+    }
+    get settingsModel() {
+        if (!this._settingsModel) {
+            this._settingsModel = require('../../../models').Settings;
+        }
+        return this._settingsModel;
+    }
+    async getOrCreateAddress({ network = 'tempo' } = {}) {
+        const cached = this.#addresses[network] || this.#readMap()[network];
+        if (cached) {
+            this.#addresses[network] = cached;
+            return cached;
+        }
+        const inflight = this.#inflight.get(network);
+        if (inflight) {
+            return await inflight;
+        }
+        const pending = this.#createAndPersist({ network })
+            .finally(() => {
+            this.#inflight.delete(network);
+        });
+        this.#inflight.set(network, pending);
+        return await pending;
+    }
+    async #createAndPersist({ network }) {
+        const stripe = this.#getStripe();
+        let depositAddress;
+        if (typeof stripe.crypto?.depositAddresses?.create === 'function') {
+            depositAddress = await stripe.crypto.depositAddresses.create({ network });
+        }
+        else if (typeof stripe.createCryptoDepositAddress === 'function') {
+            depositAddress = await stripe.createCryptoDepositAddress({ network });
+        }
+        else {
+            throw new errors_1.default.InternalServerError({
+                message: 'Stripe crypto deposit address API is unavailable'
+            });
+        }
+        const address = depositAddress?.address;
+        if (!address) {
+            throw new errors_1.default.InternalServerError({
+                message: 'Stripe did not return a crypto deposit address'
+            });
+        }
+        await this.#persist(network, address);
+        return address;
+    }
+    #readMap() {
+        const raw = this.settingsCache.get(DEPOSIT_ADDRESS_SETTING);
+        if (!raw) {
+            return {};
+        }
+        if (typeof raw === 'object' && !Array.isArray(raw)) {
+            return raw;
+        }
+        if (typeof raw === 'string') {
+            try {
+                const parsed = JSON.parse(raw);
+                if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                    return parsed;
+                }
+            }
+            catch {
+                // Legacy single-address string — treat as Tempo-only.
+            }
+            return { tempo: raw };
+        }
+        return {};
+    }
+    async #persist(network, address) {
+        this.#addresses[network] = address;
+        const map = {
+            ...this.#readMap(),
+            ...this.#addresses,
+            [network]: address
+        };
+        await this.settingsModel.edit([{
+                key: DEPOSIT_ADDRESS_SETTING,
+                value: JSON.stringify(map)
+            }], { context: { internal: true } });
+    }
+    #getStripe() {
+        const keys = this.settingsHelpers.getActiveStripeKeys();
+        const secretKey = keys?.secretKey;
+        if (!secretKey) {
+            throw new errors_1.default.IncorrectUsageError({
+                message: 'Stripe secret key is required for machine payments'
+            });
+        }
+        if (this.stripe && this.stripeSecretKey === secretKey) {
+            return this.stripe;
+        }
+        this.stripeSecretKey = secretKey;
+        this.stripe = this.stripeFactory(secretKey);
+        return this.stripe;
+    }
+}
+exports.DepositAddressStore = DepositAddressStore;

package/core/server/services/machine-payments/stripe/payment-recorder.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentRecorder = void 0;
+const stripe_1 = require("stripe");
+const deposit_address_store_1 = require("./deposit-address-store");
+const stripe_client_options_1 = require("./stripe-client-options");
+const settingsHelpers = require('../../settings-helpers');
+/**
+ * Records settled machine payments as Stripe PaymentIntents for Dashboard visibility.
+ */
+class PaymentRecorder {
+    stripeFactory;
+    settingsHelpers;
+    stripe;
+    stripeSecretKey;
+    constructor({ stripeFactory = secretKey => new stripe_1.Stripe(secretKey, {
+        ...(0, stripe_client_options_1.getMachinePaymentsStripeOptions)(deposit_address_store_1.STRIPE_MACHINE_PAYMENTS_API_VERSION)
+    }), settingsHelpersFacade = settingsHelpers } = {}) {
+        this.stripeFactory = stripeFactory;
+        this.settingsHelpers = settingsHelpersFacade;
+        this.stripe = null;
+        this.stripeSecretKey = null;
+    }
+    async record(payment) {
+        if (!payment?.reference) {
+            return null;
+        }
+        const stripe = this.#getStripe();
+        if (!stripe) {
+            return null;
+        }
+        const amountInCents = Math.round(Number(payment.amount));
+        if (!Number.isFinite(amountInCents) || amountInCents < 1) {
+            return null;
+        }
+        // SPT / card rails already create a PaymentIntent via mppx stripe.charge.
+        if (payment.method === 'spt' || payment.method === 'stripe') {
+            return payment.stripePaymentIntentId || null;
+        }
+        const network = payment.method === 'tempo' ? 'tempo' : payment.method;
+        if (!network) {
+            return null;
+        }
+        const pi = await stripe.paymentIntents.create({
+            amount: amountInCents,
+            // Tempo USDC settlement is recorded as USD cents via Stripe's
+            // transaction_verification crypto PaymentIntent flow.
+            currency: 'usd',
+            confirm: true,
+            payment_method_data: { type: 'crypto' },
+            payment_method_types: ['crypto'],
+            payment_method_options: {
+                crypto: {
+                    mode: 'transaction_verification',
+                    transaction_verification_options: {
+                        network,
+                        transaction_hash: payment.reference
+                    }
+                }
+            },
+            metadata: {
+                ghost_machine_payment: 'true',
+                post_id: payment.postId,
+                protocol: payment.protocol || 'mpp'
+            }
+        }, {
+            idempotencyKey: `machine-payment:${payment.reference}`
+        });
+        return pi.id;
+    }
+    #getStripe() {
+        const keys = this.settingsHelpers.getActiveStripeKeys();
+        const secretKey = keys?.secretKey;
+        if (!secretKey) {
+            return null;
+        }
+        if (this.stripe && this.stripeSecretKey === secretKey) {
+            return this.stripe;
+        }
+        this.stripeSecretKey = secretKey;
+        this.stripe = this.stripeFactory(secretKey);
+        return this.stripe;
+    }
+}
+exports.PaymentRecorder = PaymentRecorder;

package/core/server/services/machine-payments/stripe/stripe-client-options.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMachinePaymentsStripeOptions = getMachinePaymentsStripeOptions;
+const config = require('../../../../shared/config');
+/**
+ * Stripe client options for machine-payments preview APIs.
+ * Honours STRIPE_API_HOST/PORT/PROTOCOL so E2E can point at the fake Stripe
+ * server instead of api.stripe.com (same contract as stripe-api.js).
+ */
+function getMachinePaymentsStripeOptions(apiVersion) {
+    const options = { apiVersion };
+    const host = config.get('STRIPE_API_HOST');
+    if (host) {
+        options.host = host;
+    }
+    const port = config.get('STRIPE_API_PORT');
+    if (port !== undefined && port !== null && port !== '') {
+        options.port = parseInt(String(port), 10);
+    }
+    const protocol = config.get('STRIPE_API_PROTOCOL');
+    if (protocol) {
+        options.protocol = protocol;
+    }
+    return options;
+}

package/core/server/services/machine-payments/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/server/services/members/import-export/csv/parse.js

@@ -13,7 +13,8 @@ function isSafeColumnName(name) {
     return !(name in Object.prototype);
 }
 // headerMapping renames the CSV's headers to the columns they emit under; unmapped
-// columns carry through under their own name.
+// columns carry through under their own name, and one mapped to an empty target is
+// dropped.
 function parse(path, headerMapping) {
     return new Promise(function (resolve, reject) {
         const csvFileStream = fs_extra_1.default.createReadStream(path);
@@ -42,6 +43,13 @@ function parse(path, headerMapping) {
                     // hasOwn, not `in`: a prototype-named header would otherwise match an
                     // inherited method on the mapping and take a function as its mapped name.
                     if (headerMapping && Object.hasOwn(headerMapping, header)) {
+                        // An empty target is the caller naming a column to leave out, which
+                        // it has to name: an unnamed column carries through below, and for a
+                        // custom_fields.* column carrying through means being imported. So
+                        // omitting a column from the mapping is the opposite of excluding it.
+                        if (!headerMapping[header]) {
+                            continue;
+                        }
                         row[headerMapping[header]] = value;
                     }
                     else if (isSafeColumnName(header)) {