@jgardner04/ghost-mcp-server 1.13.3 → 1.13.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jgardner04/ghost-mcp-server",
-  "version": "1.13.3",
+  "version": "1.13.4",
   "description": "A Model Context Protocol (MCP) server for interacting with Ghost CMS via the Admin API",
   "author": "Jonathan Gardner",
   "type": "module",

package/src/__tests__/helpers/mockGhostApi.js

@@ -5,7 +5,11 @@ import { vi } from 'vitest';
  *
  * @param {Object} options - Configuration options for the mock
  * @param {Object} options.posts - Mock implementations for posts methods
+ * @param {Object} options.pages - Mock implementations for pages methods
  * @param {Object} options.tags - Mock implementations for tags methods
+ * @param {Object} options.members - Mock implementations for members methods
+ * @param {Object} options.newsletters - Mock implementations for newsletters methods
+ * @param {Object} options.tiers - Mock implementations for tiers methods
  * @param {Object} options.site - Mock implementations for site methods
  * @param {Object} options.images - Mock implementations for images methods
  * @returns {Object} Mock Ghost Admin API instance
@@ -32,6 +36,14 @@ export function createMockGhostApi(options = {}) {
       delete: vi.fn(),
       ...options.posts,
     },
+    pages: {
+      add: vi.fn(),
+      browse: vi.fn(),
+      read: vi.fn(),
+      edit: vi.fn(),
+      delete: vi.fn(),
+      ...options.pages,
+    },
     tags: {
       add: vi.fn(),
       browse: vi.fn(),
@@ -40,6 +52,30 @@ export function createMockGhostApi(options = {}) {
       delete: vi.fn(),
       ...options.tags,
     },
+    members: {
+      add: vi.fn(),
+      browse: vi.fn(),
+      read: vi.fn(),
+      edit: vi.fn(),
+      delete: vi.fn(),
+      ...options.members,
+    },
+    newsletters: {
+      add: vi.fn(),
+      browse: vi.fn(),
+      read: vi.fn(),
+      edit: vi.fn(),
+      delete: vi.fn(),
+      ...options.newsletters,
+    },
+    tiers: {
+      add: vi.fn(),
+      browse: vi.fn(),
+      read: vi.fn(),
+      edit: vi.fn(),
+      delete: vi.fn(),
+      ...options.tiers,
+    },
     site: {
       read: vi.fn(),
       ...options.site,

package/src/services/__tests__/ghostServiceImproved.members.test.js

@@ -1,48 +1,10 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
 import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
+import { mockGhostApiModule } from '../../__tests__/helpers/mockGhostApi.js';
 
-// Mock the Ghost Admin API with members support
-vi.mock('@tryghost/admin-api', () => ({
-  default: vi.fn(function () {
-    return {
-      posts: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      pages: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      tags: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      members: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      site: {
-        read: vi.fn(),
-      },
-      images: {
-        upload: vi.fn(),
-      },
-    };
-  }),
-}));
+// Mock the Ghost Admin API using shared mock factory
+vi.mock('@tryghost/admin-api', () => mockGhostApiModule());
 
 // Mock dotenv
 vi.mock('dotenv', () => mockDotenv());
@@ -69,6 +31,7 @@ import {
   searchMembers,
   api,
 } from '../ghostServiceImproved.js';
+import { GhostAPIError, NotFoundError } from '../../errors/index.js';
 
 describe('ghostServiceImproved - Members', () => {
   beforeEach(() => {
@@ -214,21 +177,20 @@ describe('ghostServiceImproved - Members', () => {
     });
 
     it('should throw validation error for missing member ID', async () => {
-      await expect(updateMember(null, { name: 'Test' })).rejects.toThrow(
-        'Member ID is required for update'
-      );
+      await expect(updateMember(null, { name: 'Test' })).rejects.toThrow('Member ID is required');
     });
 
     // NOTE: Input validation tests (invalid email in update) have been moved to
     // MCP layer tests. The service layer now relies on Zod schema validation.
 
     it('should throw not found error if member does not exist', async () => {
-      api.members.read.mockRejectedValue({
-        response: { status: 404 },
-        message: 'Member not found',
-      });
+      const error404 = new GhostAPIError('members.read', 'Member not found', 404);
+      error404.response = { status: 404 };
+      api.members.read.mockRejectedValue(error404);
 
-      await expect(updateMember('non-existent', { name: 'Test' })).rejects.toThrow();
+      const rejection = updateMember('non-existent', { name: 'Test' });
+      await expect(rejection).rejects.toBeInstanceOf(NotFoundError);
+      await expect(rejection).rejects.toThrow('Member not found');
     });
   });
 
@@ -245,16 +207,17 @@ describe('ghostServiceImproved - Members', () => {
     });
 
     it('should throw validation error for missing member ID', async () => {
-      await expect(deleteMember(null)).rejects.toThrow('Member ID is required for deletion');
+      await expect(deleteMember(null)).rejects.toThrow('Member ID is required');
     });
 
     it('should throw not found error if member does not exist', async () => {
-      api.members.delete.mockRejectedValue({
-        response: { status: 404 },
-        message: 'Member not found',
-      });
+      const error404 = new GhostAPIError('members.delete', 'Member not found', 404);
+      error404.response = { status: 404 };
+      api.members.delete.mockRejectedValue(error404);
 
-      await expect(deleteMember('non-existent')).rejects.toThrow();
+      const rejection = deleteMember('non-existent');
+      await expect(rejection).rejects.toBeInstanceOf(NotFoundError);
+      await expect(rejection).rejects.toThrow('Member not found');
     });
   });
 
@@ -396,12 +359,13 @@ describe('ghostServiceImproved - Members', () => {
     // moved to MCP layer tests. The service layer now relies on Zod schema validation.
 
     it('should throw not found error when member not found by ID', async () => {
-      api.members.read.mockRejectedValue({
-        response: { status: 404 },
-        message: 'Member not found',
-      });
+      const error404 = new GhostAPIError('members.read', 'Member not found', 404);
+      error404.response = { status: 404 };
+      api.members.read.mockRejectedValue(error404);
 
-      await expect(getMember({ id: 'non-existent' })).rejects.toThrow();
+      const rejection = getMember({ id: 'non-existent' });
+      await expect(rejection).rejects.toBeInstanceOf(NotFoundError);
+      await expect(rejection).rejects.toThrow('Member not found');
     });
 
     it('should throw not found error when member not found by email', async () => {

package/src/services/__tests__/ghostServiceImproved.newsletters.test.js

@@ -1,30 +1,25 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
 import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
+import { mockGhostApiModule } from '../../__tests__/helpers/mockGhostApi.js';
 
-// Mock dotenv before other imports
+// Mock the Ghost Admin API using shared mock factory
+vi.mock('@tryghost/admin-api', () => mockGhostApiModule());
+
+// Mock dotenv
 vi.mock('dotenv', () => mockDotenv());
 
-// Create a mock Ghost Admin API
-vi.mock('@tryghost/admin-api', () => {
-  const mockNewslettersApi = {
-    browse: vi.fn(),
-    read: vi.fn(),
-    add: vi.fn(),
-    edit: vi.fn(),
-    delete: vi.fn(),
-  };
-
-  return {
-    default: class {
-      constructor() {
-        return {
-          newsletters: mockNewslettersApi,
-        };
-      }
-    },
-    mockNewslettersApi,
-  };
-});
+// Mock logger
+vi.mock('../../utils/logger.js', () => ({
+  createContextLogger: createMockContextLogger(),
+}));
+
+// Mock fs for validateImagePath
+vi.mock('fs/promises', () => ({
+  default: {
+    access: vi.fn(),
+  },
+}));
 
 // Import after mocks are set up
 import {
@@ -33,12 +28,10 @@ import {
   createNewsletter,
   updateNewsletter,
   deleteNewsletter,
+  api,
 } from '../ghostServiceImproved.js';
 import { ValidationError, NotFoundError } from '../../errors/index.js';
 
-// Get the mock API
-const { mockNewslettersApi } = await vi.importMock('@tryghost/admin-api');
-
 describe('ghostServiceImproved - Newsletter Operations', () => {
   beforeEach(() => {
     vi.clearAllMocks();
@@ -50,37 +43,37 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
         { id: '1', name: 'Newsletter 1', slug: 'newsletter-1' },
         { id: '2', name: 'Newsletter 2', slug: 'newsletter-2' },
       ];
-      mockNewslettersApi.browse.mockResolvedValue(mockNewsletters);
+      api.newsletters.browse.mockResolvedValue(mockNewsletters);
 
       const result = await getNewsletters();
 
       expect(result).toEqual(mockNewsletters);
-      expect(mockNewslettersApi.browse).toHaveBeenCalledWith({ limit: 'all' }, {});
+      expect(api.newsletters.browse).toHaveBeenCalledWith({ limit: 'all' }, {});
     });
 
     it('should support custom limit', async () => {
       const mockNewsletters = [{ id: '1', name: 'Newsletter 1' }];
-      mockNewslettersApi.browse.mockResolvedValue(mockNewsletters);
+      api.newsletters.browse.mockResolvedValue(mockNewsletters);
 
       await getNewsletters({ limit: 5 });
 
-      expect(mockNewslettersApi.browse).toHaveBeenCalledWith({ limit: 5 }, {});
+      expect(api.newsletters.browse).toHaveBeenCalledWith({ limit: 5 }, {});
     });
 
     it('should support filter option', async () => {
       const mockNewsletters = [{ id: '1', name: 'Active Newsletter' }];
-      mockNewslettersApi.browse.mockResolvedValue(mockNewsletters);
+      api.newsletters.browse.mockResolvedValue(mockNewsletters);
 
       await getNewsletters({ filter: 'status:active' });
 
-      expect(mockNewslettersApi.browse).toHaveBeenCalledWith(
+      expect(api.newsletters.browse).toHaveBeenCalledWith(
         { limit: 'all', filter: 'status:active' },
         {}
       );
     });
 
     it('should handle empty results', async () => {
-      mockNewslettersApi.browse.mockResolvedValue([]);
+      api.newsletters.browse.mockResolvedValue([]);
 
       const result = await getNewsletters();
 
@@ -88,7 +81,7 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
     });
 
     it('should propagate API errors', async () => {
-      mockNewslettersApi.browse.mockRejectedValue(new Error('API Error'));
+      api.newsletters.browse.mockRejectedValue(new Error('API Error'));
 
       await expect(getNewsletters()).rejects.toThrow();
     });
@@ -97,24 +90,24 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
   describe('getNewsletter', () => {
     it('should retrieve a newsletter by ID', async () => {
       const mockNewsletter = { id: 'newsletter-123', name: 'My Newsletter' };
-      mockNewslettersApi.read.mockResolvedValue(mockNewsletter);
+      api.newsletters.read.mockResolvedValue(mockNewsletter);
 
       const result = await getNewsletter('newsletter-123');
 
       expect(result).toEqual(mockNewsletter);
-      expect(mockNewslettersApi.read).toHaveBeenCalledWith({}, { id: 'newsletter-123' });
+      expect(api.newsletters.read).toHaveBeenCalledWith({}, { id: 'newsletter-123' });
     });
 
     it('should throw ValidationError if ID is missing', async () => {
       await expect(getNewsletter()).rejects.toThrow(ValidationError);
       await expect(getNewsletter()).rejects.toThrow('Newsletter ID is required');
-      expect(mockNewslettersApi.read).not.toHaveBeenCalled();
+      expect(api.newsletters.read).not.toHaveBeenCalled();
     });
 
     it('should throw NotFoundError when newsletter does not exist', async () => {
       const ghostError = new Error('Not found');
       ghostError.response = { status: 404 };
-      mockNewslettersApi.read.mockRejectedValue(ghostError);
+      api.newsletters.read.mockRejectedValue(ghostError);
 
       await expect(getNewsletter('nonexistent')).rejects.toThrow(NotFoundError);
     });
@@ -127,12 +120,12 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
         description: 'Our weekly updates',
       };
       const createdNewsletter = { id: '1', ...newsletterData };
-      mockNewslettersApi.add.mockResolvedValue(createdNewsletter);
+      api.newsletters.add.mockResolvedValue(createdNewsletter);
 
       const result = await createNewsletter(newsletterData);
 
       expect(result).toEqual(createdNewsletter);
-      expect(mockNewslettersApi.add).toHaveBeenCalledWith(newsletterData, {});
+      expect(api.newsletters.add).toHaveBeenCalledWith(newsletterData, {});
     });
 
     it('should create newsletter with sender email', async () => {
@@ -143,12 +136,12 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
         sender_reply_to: 'newsletter',
       };
       const createdNewsletter = { id: '1', ...newsletterData };
-      mockNewslettersApi.add.mockResolvedValue(createdNewsletter);
+      api.newsletters.add.mockResolvedValue(createdNewsletter);
 
       const result = await createNewsletter(newsletterData);
 
       expect(result).toEqual(createdNewsletter);
-      expect(mockNewslettersApi.add).toHaveBeenCalledWith(newsletterData, {});
+      expect(api.newsletters.add).toHaveBeenCalledWith(newsletterData, {});
     });
 
     it('should create newsletter with display options', async () => {
@@ -159,12 +152,12 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
         show_header_title: false,
       };
       const createdNewsletter = { id: '1', ...newsletterData };
-      mockNewslettersApi.add.mockResolvedValue(createdNewsletter);
+      api.newsletters.add.mockResolvedValue(createdNewsletter);
 
       const result = await createNewsletter(newsletterData);
 
       expect(result).toEqual(createdNewsletter);
-      expect(mockNewslettersApi.add).toHaveBeenCalledWith(newsletterData, {});
+      expect(api.newsletters.add).toHaveBeenCalledWith(newsletterData, {});
     });
 
     it('should throw ValidationError if name is missing', async () => {
@@ -172,7 +165,7 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
 
       await expect(createNewsletter(invalidData)).rejects.toThrow(ValidationError);
       await expect(createNewsletter(invalidData)).rejects.toThrow('Newsletter validation failed');
-      expect(mockNewslettersApi.add).not.toHaveBeenCalled();
+      expect(api.newsletters.add).not.toHaveBeenCalled();
     });
 
     it('should throw ValidationError if name is empty', async () => {
@@ -180,14 +173,14 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
 
       await expect(createNewsletter(invalidData)).rejects.toThrow(ValidationError);
       await expect(createNewsletter(invalidData)).rejects.toThrow('Newsletter validation failed');
-      expect(mockNewslettersApi.add).not.toHaveBeenCalled();
+      expect(api.newsletters.add).not.toHaveBeenCalled();
     });
 
     it('should handle Ghost API validation errors', async () => {
       const newsletterData = { name: 'Newsletter' };
       const ghostError = new Error('Validation failed');
       ghostError.response = { status: 422 };
-      mockNewslettersApi.add.mockRejectedValue(ghostError);
+      api.newsletters.add.mockRejectedValue(ghostError);
 
       await expect(createNewsletter(newsletterData)).rejects.toThrow();
     });
@@ -205,20 +198,20 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
       const updateData = { name: 'New Name' };
       const updatedNewsletter = { ...existingNewsletter, ...updateData };
 
-      mockNewslettersApi.read.mockResolvedValue(existingNewsletter);
-      mockNewslettersApi.edit.mockResolvedValue(updatedNewsletter);
+      api.newsletters.read.mockResolvedValue(existingNewsletter);
+      api.newsletters.edit.mockResolvedValue(updatedNewsletter);
 
       const result = await updateNewsletter('newsletter-123', updateData);
 
       expect(result).toEqual(updatedNewsletter);
-      expect(mockNewslettersApi.read).toHaveBeenCalledWith({}, { id: 'newsletter-123' });
+      expect(api.newsletters.read).toHaveBeenCalledWith({}, { id: 'newsletter-123' });
       // Should send ONLY updateData + updated_at, NOT the full existing newsletter
-      expect(mockNewslettersApi.edit).toHaveBeenCalledWith(
+      expect(api.newsletters.edit).toHaveBeenCalledWith(
         { id: 'newsletter-123', name: 'New Name', updated_at: '2024-01-01T00:00:00.000Z' },
         {}
       );
       // Verify read-only fields are NOT sent
-      const editCallData = mockNewslettersApi.edit.mock.calls[0][0];
+      const editCallData = api.newsletters.edit.mock.calls[0][0];
       expect(editCallData).not.toHaveProperty('uuid');
       expect(editCallData).not.toHaveProperty('slug');
     });
@@ -235,13 +228,13 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
         subscribe_on_signup: false,
       };
 
-      mockNewslettersApi.read.mockResolvedValue(existingNewsletter);
-      mockNewslettersApi.edit.mockResolvedValue({ ...existingNewsletter, ...updateData });
+      api.newsletters.read.mockResolvedValue(existingNewsletter);
+      api.newsletters.edit.mockResolvedValue({ ...existingNewsletter, ...updateData });
 
       await updateNewsletter('newsletter-123', updateData);
 
       // Should send ONLY updateData + updated_at
-      expect(mockNewslettersApi.edit).toHaveBeenCalledWith(
+      expect(api.newsletters.edit).toHaveBeenCalledWith(
         { id: 'newsletter-123', ...updateData, updated_at: '2024-01-01T00:00:00.000Z' },
         {}
       );
@@ -250,13 +243,13 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
     it('should throw ValidationError if ID is missing', async () => {
       await expect(updateNewsletter()).rejects.toThrow(ValidationError);
       await expect(updateNewsletter()).rejects.toThrow('Newsletter ID is required for update');
-      expect(mockNewslettersApi.read).not.toHaveBeenCalled();
+      expect(api.newsletters.read).not.toHaveBeenCalled();
     });
 
     it('should throw NotFoundError if newsletter does not exist', async () => {
       const ghostError = new Error('Not found');
       ghostError.response = { status: 404 };
-      mockNewslettersApi.read.mockRejectedValue(ghostError);
+      api.newsletters.read.mockRejectedValue(ghostError);
 
       await expect(updateNewsletter('nonexistent', { name: 'New Name' })).rejects.toThrow(
         NotFoundError
@@ -271,13 +264,13 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
       };
       const updateData = { description: 'Updated description' };
 
-      mockNewslettersApi.read.mockResolvedValue(existingNewsletter);
-      mockNewslettersApi.edit.mockResolvedValue({ ...existingNewsletter, ...updateData });
+      api.newsletters.read.mockResolvedValue(existingNewsletter);
+      api.newsletters.edit.mockResolvedValue({ ...existingNewsletter, ...updateData });
 
       await updateNewsletter('newsletter-123', updateData);
 
       // Should send ONLY updateData + updated_at
-      expect(mockNewslettersApi.edit).toHaveBeenCalledWith(
+      expect(api.newsletters.edit).toHaveBeenCalledWith(
         {
           id: 'newsletter-123',
           description: 'Updated description',
@@ -290,24 +283,24 @@ describe('ghostServiceImproved - Newsletter Operations', () => {
 
   describe('deleteNewsletter', () => {
     it('should delete a newsletter successfully', async () => {
-      mockNewslettersApi.delete.mockResolvedValue({ id: 'newsletter-123' });
+      api.newsletters.delete.mockResolvedValue({ id: 'newsletter-123' });
 
       const result = await deleteNewsletter('newsletter-123');
 
       expect(result).toEqual({ id: 'newsletter-123' });
-      expect(mockNewslettersApi.delete).toHaveBeenCalledWith('newsletter-123', {});
+      expect(api.newsletters.delete).toHaveBeenCalledWith('newsletter-123', {});
     });
 
     it('should throw ValidationError if ID is missing', async () => {
       await expect(deleteNewsletter()).rejects.toThrow(ValidationError);
       await expect(deleteNewsletter()).rejects.toThrow('Newsletter ID is required for deletion');
-      expect(mockNewslettersApi.delete).not.toHaveBeenCalled();
+      expect(api.newsletters.delete).not.toHaveBeenCalled();
     });
 
     it('should throw NotFoundError if newsletter does not exist', async () => {
       const ghostError = new Error('Not found');
       ghostError.response = { status: 404 };
-      mockNewslettersApi.delete.mockRejectedValue(ghostError);
+      api.newsletters.delete.mockRejectedValue(ghostError);
 
       await expect(deleteNewsletter('nonexistent')).rejects.toThrow(NotFoundError);
     });

package/src/services/__tests__/ghostServiceImproved.pages.test.js

@@ -1,41 +1,10 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
 import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
+import { mockGhostApiModule } from '../../__tests__/helpers/mockGhostApi.js';
 
-// Mock the Ghost Admin API with pages support
-vi.mock('@tryghost/admin-api', () => ({
-  default: vi.fn(function () {
-    return {
-      posts: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      pages: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      tags: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      site: {
-        read: vi.fn(),
-      },
-      images: {
-        upload: vi.fn(),
-      },
-    };
-  }),
-}));
+// Mock the Ghost Admin API using shared mock factory
+vi.mock('@tryghost/admin-api', () => mockGhostApiModule());
 
 // Mock dotenv
 vi.mock('dotenv', () => mockDotenv());
@@ -64,6 +33,7 @@ import {
   validators,
 } from '../ghostServiceImproved.js';
 import { createPageSchema, updatePageSchema } from '../../schemas/pageSchemas.js';
+import { GhostAPIError, NotFoundError, ValidationError } from '../../errors/index.js';
 
 describe('ghostServiceImproved - Pages', () => {
   beforeEach(() => {
@@ -236,13 +206,13 @@ describe('ghostServiceImproved - Pages', () => {
     });
 
     it('should handle Ghost API validation errors (422)', async () => {
-      const error422 = new Error('Validation failed');
+      const error422 = new GhostAPIError('pages.add', 'Validation failed', 422);
       error422.response = { status: 422 };
       api.pages.add.mockRejectedValue(error422);
 
-      await expect(createPage({ title: 'Test', html: '<p>Content</p>' })).rejects.toThrow(
-        'Page creation failed due to validation errors'
-      );
+      const rejection = createPage({ title: 'Test', html: '<p>Content</p>' });
+      await expect(rejection).rejects.toBeInstanceOf(ValidationError);
+      await expect(rejection).rejects.toThrow('Page creation failed due to validation errors');
     });
 
     it('should NOT include tags in page creation (pages do not support tags)', async () => {
@@ -303,13 +273,13 @@ describe('ghostServiceImproved - Pages', () => {
     });
 
     it('should handle page not found (404)', async () => {
-      const error404 = new Error('Page not found');
+      const error404 = new GhostAPIError('pages.read', 'Page not found', 404);
       error404.response = { status: 404 };
       api.pages.read.mockRejectedValue(error404);
 
-      await expect(updatePage('nonexistent-id', { title: 'Updated' })).rejects.toThrow(
-        'Page not found'
-      );
+      const rejection = updatePage('nonexistent-id', { title: 'Updated' });
+      await expect(rejection).rejects.toBeInstanceOf(NotFoundError);
+      await expect(rejection).rejects.toThrow('Page not found');
     });
 
     it('should preserve updated_at timestamp for conflict resolution', async () => {
@@ -341,12 +311,67 @@ describe('ghostServiceImproved - Pages', () => {
         'Page validation failed'
       );
     });
+
+    it('should reject past published_at when existing page is scheduled (no status in update)', async () => {
+      const pageId = 'page-123';
+      const existingPage = {
+        id: pageId,
+        title: 'Scheduled Page',
+        status: 'scheduled',
+        published_at: new Date(Date.now() + 86400000).toISOString(),
+        updated_at: '2024-01-01T00:00:00.000Z',
+      };
+      const pastDate = new Date(Date.now() - 86400000).toISOString();
+
+      api.pages.read.mockResolvedValue(existingPage);
+
+      await expect(updatePage(pageId, { published_at: pastDate })).rejects.toThrow(
+        'Page validation failed'
+      );
+    });
+
+    it('should allow future published_at when existing page is scheduled (no status in update)', async () => {
+      const pageId = 'page-123';
+      const futureDate = new Date(Date.now() + 172800000).toISOString();
+      const existingPage = {
+        id: pageId,
+        title: 'Scheduled Page',
+        status: 'scheduled',
+        published_at: new Date(Date.now() + 86400000).toISOString(),
+        updated_at: '2024-01-01T00:00:00.000Z',
+      };
+
+      api.pages.read.mockResolvedValue(existingPage);
+      api.pages.edit.mockResolvedValue({ ...existingPage, published_at: futureDate });
+
+      const result = await updatePage(pageId, { published_at: futureDate });
+
+      expect(result).toBeDefined();
+    });
+
+    it('should allow published_at change when existing page is not scheduled', async () => {
+      const pageId = 'page-123';
+      const pastDate = new Date(Date.now() - 86400000).toISOString();
+      const existingPage = {
+        id: pageId,
+        title: 'Draft Page',
+        status: 'draft',
+        updated_at: '2024-01-01T00:00:00.000Z',
+      };
+
+      api.pages.read.mockResolvedValue(existingPage);
+      api.pages.edit.mockResolvedValue({ ...existingPage, published_at: pastDate });
+
+      const result = await updatePage(pageId, { published_at: pastDate });
+
+      expect(result).toBeDefined();
+    });
   });
 
   describe('deletePage', () => {
     it('should throw error when page ID is missing', async () => {
-      await expect(deletePage(null)).rejects.toThrow('Page ID is required for deletion');
-      await expect(deletePage('')).rejects.toThrow('Page ID is required for deletion');
+      await expect(deletePage(null)).rejects.toThrow('Page ID is required');
+      await expect(deletePage('')).rejects.toThrow('Page ID is required');
     });
 
     it('should delete page successfully', async () => {
@@ -361,11 +386,13 @@ describe('ghostServiceImproved - Pages', () => {
     });
 
     it('should handle page not found (404)', async () => {
-      const error404 = new Error('Page not found');
+      const error404 = new GhostAPIError('pages.delete', 'Page not found', 404);
       error404.response = { status: 404 };
       api.pages.delete.mockRejectedValue(error404);
 
-      await expect(deletePage('nonexistent-id')).rejects.toThrow('Page not found');
+      const rejection = deletePage('nonexistent-id');
+      await expect(rejection).rejects.toBeInstanceOf(NotFoundError);
+      await expect(rejection).rejects.toThrow('Page not found');
     });
   });
 
@@ -409,11 +436,13 @@ describe('ghostServiceImproved - Pages', () => {
     });
 
     it('should handle page not found (404)', async () => {
-      const error404 = new Error('Page not found');
+      const error404 = new GhostAPIError('pages.read', 'Page not found', 404);
       error404.response = { status: 404 };
       api.pages.read.mockRejectedValue(error404);
 
-      await expect(getPage('nonexistent-id')).rejects.toThrow('Page not found');
+      const rejection = getPage('nonexistent-id');
+      await expect(rejection).rejects.toBeInstanceOf(NotFoundError);
+      await expect(rejection).rejects.toThrow('Page not found');
     });
   });
 

package/src/services/__tests__/ghostServiceImproved.posts.test.js

@@ -1,48 +1,10 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
 import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
+import { mockGhostApiModule } from '../../__tests__/helpers/mockGhostApi.js';
 
-// Mock the Ghost Admin API with posts support
-vi.mock('@tryghost/admin-api', () => ({
-  default: vi.fn(function () {
-    return {
-      posts: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      pages: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      tags: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      members: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      site: {
-        read: vi.fn(),
-      },
-      images: {
-        upload: vi.fn(),
-      },
-    };
-  }),
-}));
+// Mock the Ghost Admin API using shared mock factory
+vi.mock('@tryghost/admin-api', () => mockGhostApiModule());
 
 // Mock dotenv
 vi.mock('dotenv', () => mockDotenv());
@@ -62,6 +24,7 @@ vi.mock('fs/promises', () => ({
 // Import after setting up mocks
 import { updatePost, api, validators } from '../ghostServiceImproved.js';
 import { updatePostSchema } from '../../schemas/postSchemas.js';
+import { GhostAPIError, NotFoundError } from '../../errors/index.js';
 
 describe('ghostServiceImproved - Posts (updatePost)', () => {
   beforeEach(() => {
@@ -124,22 +87,18 @@ describe('ghostServiceImproved - Posts (updatePost)', () => {
     });
 
     it('should throw error when post ID is missing', async () => {
-      await expect(updatePost(null, { title: 'Updated' })).rejects.toThrow(
-        'Post ID is required for update'
-      );
-      await expect(updatePost('', { title: 'Updated' })).rejects.toThrow(
-        'Post ID is required for update'
-      );
+      await expect(updatePost(null, { title: 'Updated' })).rejects.toThrow('Post ID is required');
+      await expect(updatePost('', { title: 'Updated' })).rejects.toThrow('Post ID is required');
     });
 
     it('should handle post not found (404)', async () => {
-      const error404 = new Error('Post not found');
+      const error404 = new GhostAPIError('posts.read', 'Post not found', 404);
       error404.response = { status: 404 };
       api.posts.read.mockRejectedValue(error404);
 
-      await expect(updatePost('nonexistent-id', { title: 'Updated' })).rejects.toThrow(
-        'Post not found'
-      );
+      const rejection = updatePost('nonexistent-id', { title: 'Updated' });
+      await expect(rejection).rejects.toBeInstanceOf(NotFoundError);
+      await expect(rejection).rejects.toThrow('Post not found');
     });
 
     it('should throw ValidationError when updating to scheduled without published_at', async () => {
@@ -177,6 +136,61 @@ describe('ghostServiceImproved - Posts (updatePost)', () => {
         {}
       );
     });
+
+    it('should reject past published_at when existing post is scheduled (no status in update)', async () => {
+      const postId = 'post-123';
+      const existingPost = {
+        id: postId,
+        title: 'Scheduled Post',
+        status: 'scheduled',
+        published_at: new Date(Date.now() + 86400000).toISOString(),
+        updated_at: '2024-01-01T00:00:00.000Z',
+      };
+      const pastDate = new Date(Date.now() - 86400000).toISOString();
+
+      api.posts.read.mockResolvedValue(existingPost);
+
+      await expect(updatePost(postId, { published_at: pastDate })).rejects.toThrow(
+        'Post validation failed'
+      );
+    });
+
+    it('should allow future published_at when existing post is scheduled (no status in update)', async () => {
+      const postId = 'post-123';
+      const futureDate = new Date(Date.now() + 172800000).toISOString();
+      const existingPost = {
+        id: postId,
+        title: 'Scheduled Post',
+        status: 'scheduled',
+        published_at: new Date(Date.now() + 86400000).toISOString(),
+        updated_at: '2024-01-01T00:00:00.000Z',
+      };
+
+      api.posts.read.mockResolvedValue(existingPost);
+      api.posts.edit.mockResolvedValue({ ...existingPost, published_at: futureDate });
+
+      const result = await updatePost(postId, { published_at: futureDate });
+
+      expect(result).toBeDefined();
+    });
+
+    it('should allow published_at change when existing post is not scheduled', async () => {
+      const postId = 'post-123';
+      const pastDate = new Date(Date.now() - 86400000).toISOString();
+      const existingPost = {
+        id: postId,
+        title: 'Draft Post',
+        status: 'draft',
+        updated_at: '2024-01-01T00:00:00.000Z',
+      };
+
+      api.posts.read.mockResolvedValue(existingPost);
+      api.posts.edit.mockResolvedValue({ ...existingPost, published_at: pastDate });
+
+      const result = await updatePost(postId, { published_at: pastDate });
+
+      expect(result).toBeDefined();
+    });
   });
 
   describe('validators.validateScheduledStatus', () => {

package/src/services/__tests__/ghostServiceImproved.tags.test.js

@@ -1,48 +1,10 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
 import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
+import { mockGhostApiModule } from '../../__tests__/helpers/mockGhostApi.js';
 
-// Mock the Ghost Admin API with tags support
-vi.mock('@tryghost/admin-api', () => ({
-  default: vi.fn(function () {
-    return {
-      posts: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      pages: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      tags: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      members: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      site: {
-        read: vi.fn(),
-      },
-      images: {
-        upload: vi.fn(),
-      },
-    };
-  }),
-}));
+// Mock the Ghost Admin API using shared mock factory
+vi.mock('@tryghost/admin-api', () => mockGhostApiModule());
 
 // Mock dotenv
 vi.mock('dotenv', () => mockDotenv());
@@ -69,6 +31,7 @@ import {
   api,
   ghostCircuitBreaker,
 } from '../ghostServiceImproved.js';
+import { GhostAPIError, NotFoundError } from '../../errors/index.js';
 
 describe('ghostServiceImproved - Tags', () => {
   beforeEach(() => {
@@ -288,12 +251,13 @@ describe('ghostServiceImproved - Tags', () => {
     });
 
     it('should throw not found error when tag does not exist', async () => {
-      api.tags.read.mockRejectedValue({
-        response: { status: 404 },
-        message: 'Tag not found',
-      });
+      const error404 = new GhostAPIError('tags.read', 'Tag not found', 404);
+      error404.response = { status: 404 };
+      api.tags.read.mockRejectedValue(error404);
 
-      await expect(getTag('non-existent')).rejects.toThrow();
+      const rejection = getTag('non-existent');
+      await expect(rejection).rejects.toBeInstanceOf(NotFoundError);
+      await expect(rejection).rejects.toThrow('Tag not found');
     });
   });
 
@@ -381,10 +345,9 @@ describe('ghostServiceImproved - Tags', () => {
       };
 
       // First call fails with duplicate error
-      api.tags.add.mockRejectedValue({
-        response: { status: 422 },
-        message: 'Tag already exists',
-      });
+      const error422 = new GhostAPIError('tags.add', 'Tag already exists', 422);
+      error422.response = { status: 422, data: { errors: [{ message: 'Tag already exists' }] } };
+      api.tags.add.mockRejectedValue(error422);
 
       // getTags returns existing tag when called with name filter
       api.tags.browse.mockResolvedValue([{ id: 'tag-1', name: 'JavaScript', slug: 'javascript' }]);
@@ -443,18 +406,17 @@ describe('ghostServiceImproved - Tags', () => {
     });
 
     it('should throw validation error for missing tag ID', async () => {
-      await expect(updateTag(null, { name: 'Test' })).rejects.toThrow(
-        'Tag ID is required for update'
-      );
+      await expect(updateTag(null, { name: 'Test' })).rejects.toThrow('Tag ID is required');
     });
 
     it('should throw not found error if tag does not exist', async () => {
-      api.tags.read.mockRejectedValue({
-        response: { status: 404 },
-        message: 'Tag not found',
-      });
+      const error404 = new GhostAPIError('tags.read', 'Tag not found', 404);
+      error404.response = { status: 404 };
+      api.tags.read.mockRejectedValue(error404);
 
-      await expect(updateTag('non-existent', { name: 'Test' })).rejects.toThrow();
+      const rejection = updateTag('non-existent', { name: 'Test' });
+      await expect(rejection).rejects.toBeInstanceOf(NotFoundError);
+      await expect(rejection).rejects.toThrow('Tag not found');
     });
   });
 
@@ -471,16 +433,17 @@ describe('ghostServiceImproved - Tags', () => {
     });
 
     it('should throw validation error for missing tag ID', async () => {
-      await expect(deleteTag(null)).rejects.toThrow('Tag ID is required for deletion');
+      await expect(deleteTag(null)).rejects.toThrow('Tag ID is required');
     });
 
     it('should throw not found error if tag does not exist', async () => {
-      api.tags.delete.mockRejectedValue({
-        response: { status: 404 },
-        message: 'Tag not found',
-      });
+      const error404 = new GhostAPIError('tags.delete', 'Tag not found', 404);
+      error404.response = { status: 404 };
+      api.tags.delete.mockRejectedValue(error404);
 
-      await expect(deleteTag('non-existent')).rejects.toThrow();
+      const rejection = deleteTag('non-existent');
+      await expect(rejection).rejects.toBeInstanceOf(NotFoundError);
+      await expect(rejection).rejects.toThrow('Tag not found');
     });
   });
 });

package/src/services/__tests__/ghostServiceImproved.tiers.test.js

@@ -1,55 +1,10 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
 import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
+import { mockGhostApiModule } from '../../__tests__/helpers/mockGhostApi.js';
 
-// Mock the Ghost Admin API with tiers support
-vi.mock('@tryghost/admin-api', () => ({
-  default: vi.fn(function () {
-    return {
-      posts: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      pages: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      tags: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      members: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      tiers: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      site: {
-        read: vi.fn(),
-      },
-      images: {
-        upload: vi.fn(),
-      },
-    };
-  }),
-}));
+// Mock the Ghost Admin API using shared mock factory
+vi.mock('@tryghost/admin-api', () => mockGhostApiModule());
 
 // Mock dotenv
 vi.mock('dotenv', () => mockDotenv());

package/src/services/ghostServiceImproved.js

@@ -57,7 +57,7 @@ const handleApiRequest = async (resource, action, data = {}, options = {}, confi
   // Main execution function
   const executeRequest = async () => {
     try {
-      console.error(`Executing Ghost API request: ${operation}`);
+      logger.info('Executing Ghost API request', { operation });
 
       let result;
 
@@ -81,7 +81,7 @@ const handleApiRequest = async (resource, action, data = {}, options = {}, confi
           result = await api[resource][action](data);
       }
 
-      console.error(`Successfully executed Ghost API request: ${operation}`);
+      logger.info('Successfully executed Ghost API request', { operation });
       return result;
     } catch (error) {
       // Transform Ghost API errors into our error types
@@ -99,17 +99,21 @@ const handleApiRequest = async (resource, action, data = {}, options = {}, confi
     return await retryWithBackoff(wrappedExecute, {
       maxAttempts: maxRetries,
       onRetry: (attempt, _error) => {
-        console.error(`Retrying ${operation} (attempt ${attempt}/${maxRetries})`);
+        logger.info('Retrying Ghost API request', { operation, attempt, maxRetries });
 
         // Log circuit breaker state if relevant
         if (useCircuitBreaker) {
           const state = ghostCircuitBreaker.getState();
-          console.error(`Circuit breaker state:`, state);
+          logger.info('Circuit breaker state', { operation, state });
         }
       },
     });
   } catch (error) {
-    console.error(`Failed to execute ${operation} after ${maxRetries} attempts:`, error.message);
+    logger.error('Failed to execute Ghost API request', {
+      operation,
+      maxRetries,
+      error: error.message,
+    });
     throw error;
   }
 };
@@ -310,12 +314,7 @@ async function deleteResource(resource, id, label) {
  */
 
 export async function getSiteInfo() {
-  try {
-    return await handleApiRequest('site', 'read');
-  } catch (error) {
-    console.error('Failed to get site info:', error);
-    throw error;
-  }
+  return handleApiRequest('site', 'read');
 }
 
 export async function createPost(postData, options = { source: 'html' }) {
@@ -348,9 +347,15 @@ export async function updatePost(postId, updateData, options = {}) {
     throw new ValidationError('Post ID is required for update');
   }
 
-  // Validate scheduled status if status is being updated
-  if (updateData.status) {
-    validators.validateScheduledStatus(updateData, 'Post');
+  // Validate scheduled status when status or published_at is being updated
+  if (updateData.status || updateData.published_at) {
+    let validationData = updateData;
+    // When only published_at changes, fetch existing status to check if post is scheduled
+    if (!updateData.status && updateData.published_at) {
+      const existing = await readResource('posts', postId, 'Post');
+      validationData = { ...updateData, status: existing.status };
+    }
+    validators.validateScheduledStatus(validationData, 'Post');
   }
 
   return updateWithOCC('posts', postId, updateData, options, 'Post');
@@ -371,12 +376,7 @@ export async function getPosts(options = {}) {
     ...options,
   };
 
-  try {
-    return await handleApiRequest('posts', 'browse', {}, defaultOptions);
-  } catch (error) {
-    console.error('Failed to get posts:', error);
-    throw error;
-  }
+  return handleApiRequest('posts', 'browse', {}, defaultOptions);
 }
 
 export async function searchPosts(query, options = {}) {
@@ -402,12 +402,7 @@ export async function searchPosts(query, options = {}) {
     filter: filterParts.join('+'),
   };
 
-  try {
-    return await handleApiRequest('posts', 'browse', {}, searchOptions);
-  } catch (error) {
-    console.error('Failed to search posts:', error);
-    throw error;
-  }
+  return handleApiRequest('posts', 'browse', {}, searchOptions);
 }
 
 /**
@@ -446,9 +441,15 @@ export async function updatePage(pageId, updateData, options = {}) {
 
   // SECURITY: HTML must be sanitized before reaching this function. See htmlContentSchema in schemas/common.js
 
-  // Validate scheduled status if status is being updated
-  if (updateData.status) {
-    validators.validateScheduledStatus(updateData, 'Page');
+  // Validate scheduled status when status or published_at is being updated
+  if (updateData.status || updateData.published_at) {
+    let validationData = updateData;
+    // When only published_at changes, fetch existing status to check if page is scheduled
+    if (!updateData.status && updateData.published_at) {
+      const existing = await readResource('pages', pageId, 'Page');
+      validationData = { ...updateData, status: existing.status };
+    }
+    validators.validateScheduledStatus(validationData, 'Page');
   }
 
   return updateWithOCC('pages', pageId, updateData, options, 'Page');
@@ -469,12 +470,7 @@ export async function getPages(options = {}) {
     ...options,
   };
 
-  try {
-    return await handleApiRequest('pages', 'browse', {}, defaultOptions);
-  } catch (error) {
-    console.error('Failed to get pages:', error);
-    throw error;
-  }
+  return handleApiRequest('pages', 'browse', {}, defaultOptions);
 }
 
 export async function searchPages(query, options = {}) {
@@ -500,12 +496,7 @@ export async function searchPages(query, options = {}) {
     filter: filterParts.join('+'),
   };
 
-  try {
-    return await handleApiRequest('pages', 'browse', {}, searchOptions);
-  } catch (error) {
-    console.error('Failed to search pages:', error);
-    throw error;
-  }
+  return handleApiRequest('pages', 'browse', {}, searchOptions);
 }
 
 export async function uploadImage(imagePath) {
@@ -557,21 +548,16 @@ export async function createTag(tagData) {
 }
 
 export async function getTags(options = {}) {
-  try {
-    const tags = await handleApiRequest(
-      'tags',
-      'browse',
-      {},
-      {
-        limit: 15,
-        ...options,
-      }
-    );
-    return tags || [];
-  } catch (error) {
-    logger.error('Failed to get tags', { error: error.message });
-    throw error;
-  }
+  const tags = await handleApiRequest(
+    'tags',
+    'browse',
+    {},
+    {
+      limit: 15,
+      ...options,
+    }
+  );
+  return tags || [];
 }
 
 export async function getTag(tagId, options = {}) {
@@ -694,13 +680,8 @@ export async function getMembers(options = {}) {
     ...options,
   };
 
-  try {
-    const members = await handleApiRequest('members', 'browse', {}, defaultOptions);
-    return members || [];
-  } catch (error) {
-    console.error('Failed to get members:', error);
-    throw error;
-  }
+  const members = await handleApiRequest('members', 'browse', {}, defaultOptions);
+  return members || [];
 }
 
 /**
@@ -764,13 +745,8 @@ export async function searchMembers(query, options = {}) {
   // Ghost uses ~ for contains/like matching
   const filter = `name:~'${sanitizedQuery}',email:~'${sanitizedQuery}'`;
 
-  try {
-    const members = await handleApiRequest('members', 'browse', {}, { filter, limit });
-    return members || [];
-  } catch (error) {
-    console.error('Failed to search members:', error);
-    throw error;
-  }
+  const members = await handleApiRequest('members', 'browse', {}, { filter, limit });
+  return members || [];
 }
 
 /**
@@ -783,13 +759,8 @@ export async function getNewsletters(options = {}) {
     ...options,
   };
 
-  try {
-    const newsletters = await handleApiRequest('newsletters', 'browse', {}, defaultOptions);
-    return newsletters || [];
-  } catch (error) {
-    console.error('Failed to get newsletters:', error);
-    throw error;
-  }
+  const newsletters = await handleApiRequest('newsletters', 'browse', {}, defaultOptions);
+  return newsletters || [];
 }
 
 export async function getNewsletter(newsletterId) {
@@ -905,13 +876,8 @@ export async function getTiers(options = {}) {
     ...options,
   };
 
-  try {
-    const tiers = await handleApiRequest('tiers', 'browse', {}, defaultOptions);
-    return tiers || [];
-  } catch (error) {
-    console.error('Failed to get tiers:', error);
-    throw error;
-  }
+  const tiers = await handleApiRequest('tiers', 'browse', {}, defaultOptions);
+  return tiers || [];
 }
 
 /**