[pull] main from TryGhost:main

.github/workflows/ci.yml

@@ -880,11 +880,11 @@ jobs:
       - name: Determine push strategy
         id: strategy
         run: |
-          # Same-org repos (e.g. TryGhost/Ghost, TryGhost/Ghost-Security) push to GHCR.
-          # External forks and cross-repo PRs use artifact-based image transfer instead.
+          # Only the canonical repo publishes to GHCR by default.
+          # Direct clones, external forks, and cross-repo PRs use artifact-based image transfer instead.
           USE_ARTIFACT="false"
-          if [ "${{ github.repository_owner }}" != "TryGhost" ]; then
-            # External fork — no GHCR push
+          if [ "${{ github.repository }}" != "TryGhost/Ghost" ]; then
+            # Non-canonical repo - no GHCR push
             USE_ARTIFACT="true"
           elif [ "${{ github.event_name }}" = "pull_request" ] && \
                [ "${{ github.event.pull_request.head.repo.full_name }}" != "${{ github.repository }}" ]; then
@@ -905,9 +905,9 @@ jobs:
             IMAGE_FULL_NAME="ghcr.io/${OWNER}/${REPO_NAME}"
           fi
 
-          # Force push on tag pushes (release images must always be published)
+          # Force push on canonical tag pushes (release images must always be published)
           IS_TAG="${{ startsWith(github.ref, 'refs/tags/v') }}"
-          if [ "$IS_TAG" = "true" ]; then
+          if [ "$IS_TAG" = "true" ] && [ "${{ github.repository }}" = "TryGhost/Ghost" ]; then
             USE_ARTIFACT="false"
           fi
 

apps/admin-x-framework/src/api/automations.ts

@@ -113,7 +113,7 @@ const buildSendEmailAction = (): AutomationSendEmailAction => ({
     id: generateActionId(),
     type: 'send_email',
     data: {
-        email_subject: 'Untitled email',
+        email_subject: '',
         email_lexical: EMPTY_EMAIL_LEXICAL,
         email_sender_name: null,
         email_sender_email: null,

apps/admin-x-framework/test/unit/api/automations.test.ts

@@ -182,7 +182,7 @@ describe('automations api helpers', () => {
             expect(next.actions).toHaveLength(1);
             const newAction = next.actions[0];
             expectSendEmailAction(newAction);
-            expect(newAction.data.email_subject).toBe('Untitled email');
+            expect(newAction.data.email_subject).toBe('');
             expect(() => JSON.parse(newAction.data.email_lexical)).not.toThrow();
             expect(JSON.parse(newAction.data.email_lexical).root.children).toEqual([]);
             expect(newAction.data.email_design_setting_id).toBe('placeholder');

apps/posts/src/views/Automations/components/email-modal/email-content-modal.tsx

@@ -111,7 +111,10 @@ const EmailContentModal: React.FC<EmailContentModalProps> = ({initialMode = 'edi
         || automatedEmails[0]
     )?.id || '';
 
-    const {formState, saveState, updateForm, setFormState, setErrors, handleSave, okProps, errors, validate} = useForm({
+    // Saving commits whatever the user has — including an empty subject or body — to the
+    // automation draft. Completeness is only enforced when publishing the automation or
+    // sending a test email (see validateForTest below), not when saving a draft.
+    const {formState, saveState, updateForm, setFormState, setErrors, handleSave, okProps, errors, clearError} = useForm({
         initialState: {
             subject: initialSubject || '',
             lexical: initialLexical || ''
@@ -120,9 +123,14 @@ const EmailContentModal: React.FC<EmailContentModalProps> = ({initialMode = 'edi
         onSave: async (state) => {
             onSave({subject: state.subject, lexical: state.lexical});
         },
-        onSaveError: handleError,
-        onValidate: getEmailValidationErrors
+        onSaveError: handleError
     });
+
+    const validateForTest = useCallback((): boolean => {
+        const newErrors = getEmailValidationErrors(formState);
+        setErrors(newErrors);
+        return Object.values(newErrors).every(error => !error);
+    }, [formState, setErrors]);
     const saveButtonLabel = okProps.label || 'Save';
     const {previewFrameState, enterPreview, exitPreview} = useEmailPreview({
         automatedEmailId: previewAutomatedEmailId,
@@ -290,7 +298,7 @@ const EmailContentModal: React.FC<EmailContentModalProps> = ({initialMode = 'edi
                                                     Test
                                                 </Button>
                                                 {showTestDropdown && (
-                                                    <TestEmailDropdown automatedEmailId={previewAutomatedEmailId} lexical={formState.lexical} subject={formState.subject} validateForm={validate} onClose={() => setShowTestDropdown(false)} />
+                                                    <TestEmailDropdown automatedEmailId={previewAutomatedEmailId} lexical={formState.lexical} subject={formState.subject} validateForm={validateForTest} onClose={() => setShowTestDropdown(false)} />
                                                 )}
                                             </div>
                                         </div>
@@ -313,6 +321,7 @@ const EmailContentModal: React.FC<EmailContentModalProps> = ({initialMode = 'edi
                                                         const nextSubject = e.target.value;
                                                         setPreviewSubjectOverride(nextSubject);
                                                         updateForm(state => ({...state, subject: nextSubject}));
+                                                        clearError('subject');
                                                     }}
                                                 />
                                                 {errors.subject && <span className='mt-2 block text-xs text-destructive'>{errors.subject}</span>}

apps/posts/src/views/Automations/components/email-modal/use-email-preview.ts

@@ -66,24 +66,24 @@ export const useEmailPreview = ({automatedEmailId, previewWelcomeEmail, setError
     const exitPreview = () => {
         previewRequestIdRef.current += 1;
         setPreviewState({status: 'idle'});
+        setErrors({});
     };
 
     const enterPreview = async (draft: EmailDraft) => {
         const requestId = previewRequestIdRef.current + 1;
         previewRequestIdRef.current = requestId;
 
         const validationErrors = getEmailValidationErrors(draft);
-        setErrors(validationErrors);
-
-        const hasValidationErrors = Boolean(validationErrors.subject || validationErrors.lexical);
-        if (hasValidationErrors) {
+        if (validationErrors.lexical) {
+            setErrors({lexical: validationErrors.lexical});
             setPreviewState({
                 status: 'invalid',
-                message: validationErrors.subject || validationErrors.lexical
+                message: validationErrors.lexical
             });
             return;
         }
 
+        setErrors({});
         setPreviewState({status: 'loading'});
 
         try {

apps/posts/src/views/Automations/editor.tsx

@@ -4,10 +4,34 @@ import React from 'react';
 import {AlertDialog, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogTitle, Button, type ButtonProps, LoadingIndicator} from '@tryghost/shade/components';
 import {AutomationDetail, AutomationStatus, useEditAutomation, useReadAutomation} from '@tryghost/admin-x-framework/api/automations';
 import {dequal} from 'dequal';
+import {toast} from 'sonner';
 import {useBlocker} from 'react-router';
 import {useConfirmUnload, useParams} from '@tryghost/admin-x-framework';
 import type {AutomationEditState} from './types';
 
+const SUBJECT_REQUIRED_MESSAGE = 'Add a subject line.';
+const BODY_REQUIRED_MESSAGE = 'Add an email body.';
+const SUBJECT_AND_BODY_REQUIRED_MESSAGE = 'Add a subject line and email body.';
+
+const isEmptyEmailLexical = (lexical: string | null | undefined): boolean => {
+    if (!lexical) {
+        return true;
+    }
+
+    try {
+        const parsed = JSON.parse(lexical);
+        const children = parsed?.root?.children;
+
+        if (!children || children.length === 0) {
+            return true;
+        }
+
+        return children.length === 1 && children[0].type === 'paragraph' && (!children[0].children || children[0].children.length === 0);
+    } catch {
+        return true;
+    }
+};
+
 const editableSlice = (automation: AutomationDetail) => ({
     status: automation.status,
     actions: automation.actions,
@@ -36,6 +60,29 @@ const isFailedEditState = (editState: AutomationEditState): boolean => {
     }
 };
 
+const getActionErrors = (automation: AutomationDetail): Record<string, string> => {
+    const errors: Record<string, string> = {};
+
+    for (const action of automation.actions) {
+        if (action.type !== 'send_email') {
+            continue;
+        }
+
+        const missingSubject = !action.data.email_subject.trim();
+        const missingBody = isEmptyEmailLexical(action.data.email_lexical);
+
+        if (missingSubject && missingBody) {
+            errors[action.id] = SUBJECT_AND_BODY_REQUIRED_MESSAGE;
+        } else if (missingSubject) {
+            errors[action.id] = SUBJECT_REQUIRED_MESSAGE;
+        } else if (missingBody) {
+            errors[action.id] = BODY_REQUIRED_MESSAGE;
+        }
+    }
+
+    return errors;
+};
+
 const AutomationEditor: React.FC = () => {
     const {id = ''} = useParams<{id: string}>();
 
@@ -46,6 +93,7 @@ const AutomationEditor: React.FC = () => {
 
     const editMutation = useEditAutomation();
     const [editState, setEditState] = React.useState<AutomationEditState>('idle');
+    const [actionErrors, setActionErrors] = React.useState<Record<string, string>>({});
 
     // Draft is the user-facing, locally mutable copy. The React Query cache stays as server truth;
     // staged edits (adding steps, etc.) live here until the user publishes. Seeded once when the
@@ -67,11 +115,35 @@ const AutomationEditor: React.FC = () => {
 
     const onDraftChange = (next: AutomationDetail) => {
         setDraft(next);
+        setActionErrors((oldErrors) => {
+            if (Object.keys(oldErrors).length === 0) {
+                return oldErrors;
+            }
+
+            const nextErrors = getActionErrors(next);
+            return Object.fromEntries(
+                Object.entries(oldErrors).filter(([actionId]) => nextErrors[actionId])
+            );
+        });
         setEditState(prev => (
             isFailedEditState(prev) ? 'idle' : prev
         ));
     };
 
+    const validateActionErrors = (automationToValidate: AutomationDetail, errorState: AutomationEditState): boolean => {
+        const nextActionErrors = getActionErrors(automationToValidate);
+        if (Object.keys(nextActionErrors).length > 0) {
+            setActionErrors(nextActionErrors);
+            setEditState(errorState);
+            toast.error('Automation couldn’t be saved', {
+                description: 'Fix the highlighted steps and try again.'
+            });
+            return false;
+        }
+
+        return true;
+    };
+
     const save = (statusToSave?: AutomationStatus) => {
         if (!draft) {
             throw new Error('Cannot edit an automation that has not loaded.');
@@ -106,6 +178,10 @@ const AutomationEditor: React.FC = () => {
         }
         }
 
+        if (newStatus === 'active' && !validateActionErrors(draft, errorState)) {
+            return;
+        }
+
         setEditState(requestState);
 
         editMutation.mutate(
@@ -118,9 +194,26 @@ const AutomationEditor: React.FC = () => {
             {
                 onSuccess: (response) => {
                     setDraft(response.automations[0]);
+                    setActionErrors({});
                     setEditState('idle');
                 },
-                onError: () => setEditState(errorState)
+                onError: (error) => {
+                    void error;
+                    const nextActionErrors = newStatus === 'active' ? getActionErrors(draft) : {};
+                    const hasActionErrors = Object.keys(nextActionErrors).length > 0;
+                    if (hasActionErrors) {
+                        setActionErrors(nextActionErrors);
+                    }
+
+                    setEditState(errorState);
+                    if (hasActionErrors) {
+                        toast.error('Automation couldn’t be saved', {
+                            description: 'Fix the highlighted steps and try again.'
+                        });
+                    } else {
+                        toast.error('Automation couldn’t be saved');
+                    }
+                }
             }
         );
     };
@@ -260,18 +353,22 @@ const AutomationEditor: React.FC = () => {
     };
 
     const onPublish = (): void => {
-        const draftStatus = draft?.status;
-        switch (draftStatus) {
-        case undefined:
+        if (!draft) {
             throw new Error('Cannot publish an automation that has not loaded.');
+        }
+
+        switch (draft.status) {
         case 'active':
+            if (!validateActionErrors(draft, 'idle')) {
+                return;
+            }
             setEditState('confirming re-publish');
             break;
         case 'inactive':
             save('active');
             break;
         default: {
-            const _exhaustive: never = draftStatus;
+            const _exhaustive: never = draft.status;
             throw new Error(`Unhandled status: ${_exhaustive}`);
         }
         }
@@ -306,6 +403,7 @@ const AutomationEditor: React.FC = () => {
             />
 
             <AutomationCanvas
+                actionErrors={actionErrors}
                 automation={draft}
                 isError={isError}
                 isLoading={isLoadingAutomation}