@adsim/wordpress-mcp-server 1.0.0 → 3.1.0

package/tests/unit/tools/themes.test.js

@@ -0,0 +1,163 @@
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+
+vi.mock('node-fetch', () => ({ default: vi.fn() }));
+
+import fetch from 'node-fetch';
+import { handleToolCall } from '../../../index.js';
+import { mockSuccess, mockError, getAuditLogs, makeRequest, parseResult } from '../../helpers/mockWpRequest.js';
+
+function call(name, args = {}) {
+  return handleToolCall(makeRequest(name, args));
+}
+
+let consoleSpy;
+beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+afterEach(() => { consoleSpy.mockRestore(); });
+
+// =========================================================================
+// Shared mock data
+// =========================================================================
+
+const themesList = [
+  {
+    stylesheet: 'twentytwentyfour',
+    template: 'twentytwentyfour',
+    name: { rendered: 'Twenty Twenty-Four' },
+    description: { rendered: '<p>Modern theme</p>' },
+    status: 'active',
+    version: '1.0',
+    author: { rendered: 'WordPress' },
+    author_uri: 'https://wordpress.org',
+    theme_uri: 'https://wordpress.org/themes/twentytwentyfour',
+    requires_wp: '6.4',
+    requires_php: '7.0',
+    tags: { rendered: ['blog', 'one-column'] },
+  },
+  {
+    stylesheet: 'twentytwentythree',
+    template: 'twentytwentythree',
+    name: { rendered: 'Twenty Twenty-Three' },
+    description: { rendered: '<p>Classic theme</p>' },
+    status: 'inactive',
+    version: '1.2',
+    author: { rendered: 'WordPress' },
+    author_uri: '',
+    theme_uri: '',
+    requires_wp: '6.1',
+    requires_php: '5.6',
+    tags: { rendered: ['blog', 'two-column'] },
+  },
+];
+
+const singleTheme = themesList[0];
+
+// =========================================================================
+// wp_list_themes
+// =========================================================================
+
+describe('wp_list_themes', () => {
+  it('SUCCESS — returns total, active_theme, and themes array', async () => {
+    mockSuccess(themesList);
+
+    const res = await call('wp_list_themes');
+    const data = parseResult(res);
+
+    expect(data.total).toBe(2);
+    expect(data.active_theme).toBe('Twenty Twenty-Four');
+    expect(data.themes).toHaveLength(2);
+
+    const tt4 = data.themes.find(t => t.stylesheet === 'twentytwentyfour');
+    expect(tt4.template).toBe('twentytwentyfour');
+    expect(tt4.name).toBe('Twenty Twenty-Four');
+    expect(tt4.description).toBe('Modern theme');
+    expect(tt4.status).toBe('active');
+    expect(tt4.version).toBe('1.0');
+    expect(tt4.author).toBe('WordPress');
+    expect(tt4.tags).toEqual(['blog', 'one-column']);
+  });
+
+  it('SUCCESS — active_theme_name is extracted from the active theme', async () => {
+    mockSuccess(themesList);
+
+    const res = await call('wp_list_themes');
+    const data = parseResult(res);
+
+    // active_theme should be the name.rendered of the theme with status 'active'
+    expect(data.active_theme).toBe('Twenty Twenty-Four');
+  });
+
+  it('ERROR 403 — returns message about switch_themes capability', async () => {
+    mockError(403, '{"code":"rest_forbidden"}');
+
+    const res = await call('wp_list_themes');
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('switch_themes');
+  });
+
+  it('AUDIT — logs list action on success', async () => {
+    mockSuccess(themesList);
+
+    await call('wp_list_themes');
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_list_themes');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+  });
+});
+
+// =========================================================================
+// wp_get_theme
+// =========================================================================
+
+describe('wp_get_theme', () => {
+  it('SUCCESS — returns all theme fields with tags as array', async () => {
+    mockSuccess(singleTheme);
+
+    const res = await call('wp_get_theme', { stylesheet: 'twentytwentyfour' });
+    const data = parseResult(res);
+
+    expect(data.stylesheet).toBe('twentytwentyfour');
+    expect(data.template).toBe('twentytwentyfour');
+    expect(data.name).toBe('Twenty Twenty-Four');
+    expect(data.description).toBe('Modern theme');
+    expect(data.status).toBe('active');
+    expect(data.version).toBe('1.0');
+    expect(data.author).toBe('WordPress');
+    expect(data.author_uri).toBe('https://wordpress.org');
+    expect(data.theme_uri).toBe('https://wordpress.org/themes/twentytwentyfour');
+    expect(data.requires_wp).toBe('6.4');
+    expect(data.requires_php).toBe('7.0');
+    expect(Array.isArray(data.tags)).toBe(true);
+    expect(data.tags).toEqual(['blog', 'one-column']);
+  });
+
+  it('ERROR 404 — returns message mentioning wp_list_themes', async () => {
+    mockError(404, '{"code":"rest_theme_not_found"}');
+
+    const res = await call('wp_get_theme', { stylesheet: 'nonexistent' });
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('wp_list_themes');
+  });
+
+  it('ERROR 403 — returns message about switch_themes capability', async () => {
+    mockError(403, '{"code":"rest_forbidden"}');
+
+    const res = await call('wp_get_theme', { stylesheet: 'twentytwentyfour' });
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('switch_themes');
+  });
+
+  it('AUDIT — logs read action on success', async () => {
+    mockSuccess(singleTheme);
+
+    await call('wp_get_theme', { stylesheet: 'twentytwentyfour' });
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_get_theme');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.target).toBe('twentytwentyfour');
+    expect(entry.target_type).toBe('theme');
+  });
+});

package/tests/unit/tools/users.test.js

@@ -0,0 +1,113 @@
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+
+vi.mock('node-fetch', () => ({ default: vi.fn() }));
+
+import fetch from 'node-fetch';
+import { handleToolCall } from '../../../index.js';
+import { mockSuccess, mockError, getAuditLogs, makeRequest, parseResult } from '../../helpers/mockWpRequest.js';
+
+function call(name, args = {}) {
+  return handleToolCall(makeRequest(name, args));
+}
+
+// ────────────────────────────────────────────────────────────
+// wp_list_users
+// ────────────────────────────────────────────────────────────
+
+describe('wp_list_users', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns formatted user list on success', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { id: 1, name: 'Admin', slug: 'admin', link: 'https://test.example.com/author/admin', roles: ['administrator'], avatar_urls: { '96': 'https://secure.gravatar.com/avatar/xxx?s=96' } }
+    ]));
+
+    const result = await call('wp_list_users');
+    const data = parseResult(result);
+
+    expect(data.total).toBe(1);
+    expect(data.users).toHaveLength(1);
+    expect(data.users[0].id).toBe(1);
+    expect(data.users[0].name).toBe('Admin');
+    expect(data.users[0].slug).toBe('admin');
+    expect(data.users[0].link).toBe('https://test.example.com/author/admin');
+    expect(data.users[0].roles).toEqual(['administrator']);
+    expect(data.users[0].avatar).toBe('https://secure.gravatar.com/avatar/xxx?s=96');
+  });
+
+  it('returns error on 403', async () => {
+    fetch.mockResolvedValue(mockError(403));
+
+    const result = await call('wp_list_users');
+
+    expect(result.isError).toBe(true);
+  });
+
+  it('returns error on 404', async () => {
+    fetch.mockResolvedValue(mockError(404));
+
+    const result = await call('wp_list_users');
+
+    expect(result.isError).toBe(true);
+  });
+
+  it('logs audit entry with status success', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { id: 1, name: 'Admin', slug: 'admin', link: 'https://test.example.com/author/admin', roles: ['administrator'], avatar_urls: { '96': 'https://secure.gravatar.com/avatar/xxx?s=96' } }
+    ]));
+
+    await call('wp_list_users');
+    const logs = getAuditLogs(consoleSpy);
+    const entry = logs.find(l => l.tool === 'wp_list_users');
+
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+  });
+
+  it('returns multiple users correctly', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { id: 1, name: 'Admin', slug: 'admin', link: 'https://test.example.com/author/admin', roles: ['administrator'], avatar_urls: { '96': 'https://secure.gravatar.com/avatar/aaa?s=96' } },
+      { id: 2, name: 'Editor', slug: 'editor', link: 'https://test.example.com/author/editor', roles: ['editor'], avatar_urls: { '96': 'https://secure.gravatar.com/avatar/bbb?s=96' } },
+      { id: 3, name: 'Author', slug: 'author', link: 'https://test.example.com/author/author', roles: ['author'], avatar_urls: { '96': 'https://secure.gravatar.com/avatar/ccc?s=96' } }
+    ]));
+
+    const result = await call('wp_list_users');
+    const data = parseResult(result);
+
+    expect(data.total).toBe(3);
+    expect(data.users).toHaveLength(3);
+    expect(data.users[0].name).toBe('Admin');
+    expect(data.users[1].name).toBe('Editor');
+    expect(data.users[2].name).toBe('Author');
+    expect(data.users[1].roles).toEqual(['editor']);
+  });
+
+  it('passes search parameter correctly', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { id: 1, name: 'Admin', slug: 'admin', link: 'https://test.example.com/author/admin', roles: ['administrator'], avatar_urls: { '96': 'https://secure.gravatar.com/avatar/xxx?s=96' } }
+    ]));
+
+    const result = await call('wp_list_users', { search: 'admin' });
+    const data = parseResult(result);
+
+    expect(data.total).toBe(1);
+    expect(data.users[0].name).toBe('Admin');
+
+    // Verify fetch was called with search param in URL
+    const fetchUrl = fetch.mock.calls[0][0];
+    expect(fetchUrl).toContain('search=admin');
+  });
+
+  it('handles users without avatar_urls', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { id: 1, name: 'NoAvatar', slug: 'noavatar', link: 'https://test.example.com/author/noavatar', roles: ['subscriber'] }
+    ]));
+
+    const result = await call('wp_list_users');
+    const data = parseResult(result);
+
+    expect(data.users[0].avatar).toBeUndefined();
+  });
+});

package/tests/unit/transport/http.test.js

@@ -0,0 +1,300 @@
+/**
+ * Tests for HTTP Streamable Transport and Bearer auth.
+ *
+ * Covers:
+ *  - validateBearerToken: valid, invalid, absent, authToken null
+ *  - Origin validation: allowed, disallowed, absent
+ *  - Health endpoint: 200 + correct JSON
+ *  - Session ID: UUID v4 format, uniqueness
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { validateBearerToken } from '../../../src/auth/bearer.js';
+
+// ─────────────────────────────────────────────────────────────
+// validateBearerToken
+// ─────────────────────────────────────────────────────────────
+
+describe('validateBearerToken', () => {
+  let consoleSpy;
+
+  beforeEach(() => {
+    consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+  afterEach(() => consoleSpy.mockRestore());
+
+  function fakeReq(authHeader) {
+    return {
+      headers: authHeader !== undefined ? { authorization: authHeader } : {},
+      socket: { remoteAddress: '127.0.0.1' },
+      url: '/mcp',
+    };
+  }
+
+  it('accepts a valid token', () => {
+    const result = validateBearerToken(fakeReq('Bearer my-secret'), 'my-secret');
+    expect(result.valid).toBe(true);
+    expect(result.status).toBeUndefined();
+  });
+
+  it('rejects an invalid token', () => {
+    const result = validateBearerToken(fakeReq('Bearer wrong-token'), 'my-secret');
+    expect(result.valid).toBe(false);
+    expect(result.status).toBe(401);
+    expect(result.body).toEqual({ error: 'Unauthorized', code: 'INVALID_TOKEN' });
+  });
+
+  it('rejects when Authorization header is absent', () => {
+    const result = validateBearerToken(fakeReq(undefined), 'my-secret');
+    expect(result.valid).toBe(false);
+    expect(result.status).toBe(401);
+    expect(result.body.code).toBe('INVALID_TOKEN');
+  });
+
+  it('rejects a malformed Authorization header (no Bearer prefix)', () => {
+    const result = validateBearerToken(fakeReq('Basic abc123'), 'my-secret');
+    expect(result.valid).toBe(false);
+    expect(result.status).toBe(401);
+  });
+
+  it('passes when authToken is null (auth disabled)', () => {
+    const result = validateBearerToken(fakeReq(undefined), null);
+    expect(result.valid).toBe(true);
+  });
+
+  it('passes when authToken is null even with a token provided', () => {
+    const result = validateBearerToken(fakeReq('Bearer something'), null);
+    expect(result.valid).toBe(true);
+  });
+
+  it('logs auth failure to stderr as JSON', () => {
+    validateBearerToken(fakeReq('Bearer bad'), 'good');
+    expect(consoleSpy).toHaveBeenCalled();
+    const logLine = consoleSpy.mock.calls[0][0];
+    expect(logLine).toContain('[AUTH]');
+    const json = JSON.parse(logLine.replace('[AUTH] ', ''));
+    expect(json.event).toBe('auth_failure');
+    expect(json.ip).toBe('127.0.0.1');
+    expect(json.path).toBe('/mcp');
+    expect(json.timestamp).toBeDefined();
+  });
+});
+
+// ─────────────────────────────────────────────────────────────
+// HTTP server integration tests (health, origin, session)
+// ─────────────────────────────────────────────────────────────
+
+/**
+ * Helper: start a temporary HTTP server from HttpTransportManager,
+ * run a test, then close.
+ */
+async function withHttpServer(config, fn) {
+  const { HttpTransportManager } = await import('../../../src/transport/http.js');
+  const { Server } = await import('@modelcontextprotocol/sdk/server/index.js');
+
+  function serverFactory() {
+    return new Server(
+      { name: 'test-mcp', version: '0.0.1' },
+      { capabilities: { tools: {} } },
+    );
+  }
+
+  const manager = new HttpTransportManager();
+  const httpServer = manager.createServer(serverFactory, config);
+
+  await new Promise((resolve) => httpServer.listen(0, '127.0.0.1', resolve));
+  const { port } = httpServer.address();
+
+  try {
+    await fn({ port, httpServer });
+  } finally {
+    await new Promise((resolve) => httpServer.close(resolve));
+  }
+}
+
+function httpGet(port, path, headers = {}) {
+  return fetch(`http://127.0.0.1:${port}${path}`, { method: 'GET', headers });
+}
+
+function httpPost(port, path, body, headers = {}) {
+  return fetch(`http://127.0.0.1:${port}${path}`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Accept': 'application/json, text/event-stream',
+      ...headers,
+    },
+    body: JSON.stringify(body),
+  });
+}
+
+function httpDelete(port, path, headers = {}) {
+  return fetch(`http://127.0.0.1:${port}${path}`, { method: 'DELETE', headers });
+}
+
+describe('Health endpoint', () => {
+  let consoleSpy;
+  beforeEach(() => { consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => consoleSpy.mockRestore());
+
+  it('returns 200 with correct JSON', async () => {
+    await withHttpServer({}, async ({ port }) => {
+      const res = await httpGet(port, '/health');
+      expect(res.status).toBe(200);
+      const data = await res.json();
+      expect(data).toEqual({ status: 'ok', transport: 'http', version: '3.0.0' });
+    });
+  });
+
+  it('returns 404 for unknown paths', async () => {
+    await withHttpServer({}, async ({ port }) => {
+      const res = await httpGet(port, '/unknown');
+      expect(res.status).toBe(404);
+    });
+  });
+});
+
+describe('Origin validation', () => {
+  let consoleSpy;
+  beforeEach(() => { consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => consoleSpy.mockRestore());
+
+  it('allows request when origin is in allowedOrigins', async () => {
+    await withHttpServer({ allowedOrigins: ['http://allowed.com'] }, async ({ port }) => {
+      const res = await httpPost(port, '/mcp', { method: 'initialize' }, {
+        Origin: 'http://allowed.com',
+      });
+      // Should not be 403 (may be 400 from MCP, but NOT 403)
+      expect(res.status).not.toBe(403);
+    });
+  });
+
+  it('rejects request when origin is not in allowedOrigins', async () => {
+    await withHttpServer({ allowedOrigins: ['http://allowed.com'] }, async ({ port }) => {
+      const res = await httpPost(port, '/mcp', { method: 'initialize' }, {
+        Origin: 'http://evil.com',
+      });
+      expect(res.status).toBe(403);
+      const data = await res.json();
+      expect(data.code).toBe('ORIGIN_NOT_ALLOWED');
+    });
+  });
+
+  it('allows request when no Origin header is sent and allowedOrigins is set', async () => {
+    await withHttpServer({ allowedOrigins: ['http://allowed.com'] }, async ({ port }) => {
+      const res = await httpPost(port, '/mcp', { method: 'initialize' });
+      expect(res.status).not.toBe(403);
+    });
+  });
+
+  it('allows any origin when allowedOrigins is empty', async () => {
+    await withHttpServer({ allowedOrigins: [] }, async ({ port }) => {
+      const res = await httpPost(port, '/mcp', { method: 'initialize' }, {
+        Origin: 'http://any.com',
+      });
+      expect(res.status).not.toBe(403);
+    });
+  });
+});
+
+describe('Bearer auth on HTTP endpoints', () => {
+  let consoleSpy;
+  beforeEach(() => { consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => consoleSpy.mockRestore());
+
+  it('rejects /mcp without token when authToken is set', async () => {
+    await withHttpServer({ authToken: 'secret123' }, async ({ port }) => {
+      const res = await httpPost(port, '/mcp', { method: 'initialize' });
+      expect(res.status).toBe(401);
+    });
+  });
+
+  it('allows /mcp with valid token', async () => {
+    await withHttpServer({ authToken: 'secret123' }, async ({ port }) => {
+      const res = await httpPost(port, '/mcp', { method: 'initialize' }, {
+        Authorization: 'Bearer secret123',
+      });
+      expect(res.status).not.toBe(401);
+    });
+  });
+
+  it('health endpoint does not require auth', async () => {
+    await withHttpServer({ authToken: 'secret123' }, async ({ port }) => {
+      const res = await httpGet(port, '/health');
+      expect(res.status).toBe(200);
+    });
+  });
+});
+
+describe('Session management', () => {
+  let consoleSpy;
+  beforeEach(() => { consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => consoleSpy.mockRestore());
+
+  it('initialize request returns Mcp-Session-Id in UUID v4 format', async () => {
+    await withHttpServer({}, async ({ port }) => {
+      const res = await httpPost(port, '/mcp', {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+          protocolVersion: '2025-03-26',
+          capabilities: {},
+          clientInfo: { name: 'test', version: '1.0' },
+        },
+      });
+      const sessionId = res.headers.get('mcp-session-id');
+      expect(sessionId).not.toBeNull();
+      expect(typeof sessionId).toBe('string');
+      // UUID v4 format: 8-4-4-4-12 hex
+      expect(sessionId).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+    });
+  });
+
+  it('different sessions produce unique IDs', async () => {
+    await withHttpServer({}, async ({ port }) => {
+      const body = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+          protocolVersion: '2025-03-26',
+          capabilities: {},
+          clientInfo: { name: 'test', version: '1.0' },
+        },
+      };
+      const res1 = await httpPost(port, '/mcp', body);
+      const id1 = res1.headers.get('mcp-session-id');
+
+      const res2 = await httpPost(port, '/mcp', { ...body, id: 2 });
+      const id2 = res2.headers.get('mcp-session-id');
+
+      expect(id1).not.toBeNull();
+      expect(id2).not.toBeNull();
+      expect(id1).not.toBe(id2);
+    });
+  }, 15000);
+
+  it('rejects POST without session ID for non-init requests', async () => {
+    await withHttpServer({}, async ({ port }) => {
+      const res = await httpPost(port, '/mcp', {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/list',
+        params: {},
+      });
+      expect(res.status).toBe(400);
+      const data = await res.json();
+      expect(data.code).toBe('INVALID_SESSION');
+    });
+  });
+
+  it('DELETE with invalid session returns 404', async () => {
+    await withHttpServer({}, async ({ port }) => {
+      const res = await httpDelete(port, '/mcp', {
+        'Mcp-Session-Id': 'nonexistent-session-id',
+      });
+      expect(res.status).toBe(404);
+    });
+  });
+});

package/vitest.config.js

@@ -0,0 +1,12 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    env: {
+      NODE_ENV: 'test',
+      WP_API_URL: 'https://test.example.com',
+      WP_API_USERNAME: 'testuser',
+      WP_API_PASSWORD: 'testpass'
+    }
+  }
+});

package/dist/constants.d.ts

@@ -1,13 +0,0 @@
-export declare const SERVER_NAME = "wordpress-mcp-server";
-export declare const SERVER_VERSION = "1.0.0";
-export declare const CHARACTER_LIMIT = 50000;
-export declare const WP_REST_BASE = "/wp-json/wp/v2";
-export declare const DEFAULT_PER_PAGE = 10;
-export declare const MAX_PER_PAGE = 100;
-export declare const POST_STATUSES: readonly ["publish", "draft", "pending", "private", "future", "trash"];
-export type PostStatus = (typeof POST_STATUSES)[number];
-export declare const POST_ORDERBYS: readonly ["date", "id", "title", "slug", "modified", "author", "relevance"];
-export type PostOrderBy = (typeof POST_ORDERBYS)[number];
-export declare const ORDER_DIRECTIONS: readonly ["asc", "desc"];
-export type OrderDirection = (typeof ORDER_DIRECTIONS)[number];
-//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,yBAAyB,CAAC;AAClD,eAAO,MAAM,cAAc,UAAU,CAAC;AAEtC,eAAO,MAAM,eAAe,QAAQ,CAAC;AAErC,eAAO,MAAM,YAAY,mBAAmB,CAAC;AAE7C,eAAO,MAAM,gBAAgB,KAAK,CAAC;AACnC,eAAO,MAAM,YAAY,MAAM,CAAC;AAEhC,eAAO,MAAM,aAAa,wEAAyE,CAAC;AACpG,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAExD,eAAO,MAAM,aAAa,6EAA8E,CAAC;AACzG,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzD,eAAO,MAAM,gBAAgB,0BAA2B,CAAC;AACzD,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/constants.js

@@ -1,10 +0,0 @@
-export const SERVER_NAME = "wordpress-mcp-server";
-export const SERVER_VERSION = "1.0.0";
-export const CHARACTER_LIMIT = 50000;
-export const WP_REST_BASE = "/wp-json/wp/v2";
-export const DEFAULT_PER_PAGE = 10;
-export const MAX_PER_PAGE = 100;
-export const POST_STATUSES = ["publish", "draft", "pending", "private", "future", "trash"];
-export const POST_ORDERBYS = ["date", "id", "title", "slug", "modified", "author", "relevance"];
-export const ORDER_DIRECTIONS = ["asc", "desc"];
-//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,WAAW,GAAG,sBAAsB,CAAC;AAClD,MAAM,CAAC,MAAM,cAAc,GAAG,OAAO,CAAC;AAEtC,MAAM,CAAC,MAAM,eAAe,GAAG,KAAK,CAAC;AAErC,MAAM,CAAC,MAAM,YAAY,GAAG,gBAAgB,CAAC;AAE7C,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,CAAC;AACnC,MAAM,CAAC,MAAM,YAAY,GAAG,GAAG,CAAC;AAEhC,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,CAAU,CAAC;AAGpG,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,CAAU,CAAC;AAGzG,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,MAAM,CAAU,CAAC"}

package/dist/index.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -1,33 +0,0 @@
-#!/usr/bin/env node
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { createClientFromEnv } from "./services/wp-client.js";
-import { registerPostsTools } from "./tools/posts.js";
-import { registerTaxonomyTools } from "./tools/taxonomy.js";
-import { registerSEOTools } from "./tools/seo.js";
-import { registerContentTools } from "./tools/content.js";
-import { SERVER_NAME, SERVER_VERSION } from "./constants.js";
-async function main() {
-    // Create WordPress API client from environment variables
-    const client = createClientFromEnv();
-    // Create MCP server
-    const server = new McpServer({
-        name: SERVER_NAME,
-        version: SERVER_VERSION,
-    });
-    // Register all tools
-    registerPostsTools(server, client);
-    registerTaxonomyTools(server, client);
-    registerSEOTools(server, client);
-    registerContentTools(server, client);
-    // Start server with stdio transport
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error(`${SERVER_NAME} v${SERVER_VERSION} started successfully`);
-    console.error(`Connected to: ${process.env.WP_API_URL}`);
-}
-main().catch((error) => {
-    console.error(`Fatal error starting ${SERVER_NAME}:`, error.message);
-    process.exit(1);
-});
-//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAE7D,KAAK,UAAU,IAAI;IACjB,yDAAyD;IACzD,MAAM,MAAM,GAAG,mBAAmB,EAAE,CAAC;IAErC,oBAAoB;IACpB,MAAM,MAAM,GAAG,IAAI,SAAS,CAAC;QAC3B,IAAI,EAAE,WAAW;QACjB,OAAO,EAAE,cAAc;KACxB,CAAC,CAAC;IAEH,qBAAqB;IACrB,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,qBAAqB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,gBAAgB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,oBAAoB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAErC,oCAAoC;IACpC,MAAM,SAAS,GAAG,IAAI,oBAAoB,EAAE,CAAC;IAC7C,MAAM,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAEhC,OAAO,CAAC,KAAK,CAAC,GAAG,WAAW,KAAK,cAAc,uBAAuB,CAAC,CAAC;IACxE,OAAO,CAAC,KAAK,CAAC,iBAAiB,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC;AAC3D,CAAC;AAED,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,KAAY,EAAE,EAAE;IAC5B,OAAO,CAAC,KAAK,CAAC,wBAAwB,WAAW,GAAG,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;IACrE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC"}