How to Integrate Replit with Ghost

1import os
2import time
3import hmac
4import hashlib
5import struct
6import base64
7import json
8import requests
9from typing import Optional
10
11GHOST_URL = os.environ["GHOST_URL"].rstrip("/")
12CONTENT_KEY = os.environ["GHOST_CONTENT_API_KEY"]
13ADMIN_API_KEY = os.environ["GHOST_ADMIN_API_KEY"]
14
15# ---- Content API (public, read-only) ----
16
17def get_posts(limit: int = 10, include: str = "tags,authors", filter: str = "") -> list:
18    """Fetch published posts from Ghost Content API."""
19    params = {
20        "key": CONTENT_KEY,
21        "limit": limit,
22        "include": include,
23        "order": "published_at desc"
24    }
25    if filter:
26        params["filter"] = filter
27    response = requests.get(f"{GHOST_URL}/ghost/api/content/posts/", params=params)
28    response.raise_for_status()
29    return response.json().get("posts", [])
30
31def get_post_by_slug(slug: str) -> Optional[dict]:
32    """Fetch a single post by its slug."""
33    params = {"key": CONTENT_KEY, "include": "tags,authors"}
34    response = requests.get(f"{GHOST_URL}/ghost/api/content/posts/slug/{slug}/", params=params)
35    if response.status_code == 404:
36        return None
37    response.raise_for_status()
38    posts = response.json().get("posts", [])
39    return posts[0] if posts else None
40
41def get_tags() -> list:
42    """Fetch all tags from Ghost."""
43    params = {"key": CONTENT_KEY, "limit": "all"}
44    response = requests.get(f"{GHOST_URL}/ghost/api/content/tags/", params=params)
45    response.raise_for_status()
46    return response.json().get("tags", [])
47
48# ---- Admin API (requires JWT) ----
49
50def _generate_admin_jwt() -> str:
51    """Generate a Ghost Admin API JWT token (valid for 5 minutes)."""
52    key_id, secret = ADMIN_API_KEY.split(":")
53    header = base64.urlsafe_b64encode(json.dumps({"alg": "HS256", "kid": key_id, "typ": "JWT"}).encode()).rstrip(b"=").decode()
54    iat = int(time.time())
55    payload = base64.urlsafe_b64encode(json.dumps({"iat": iat, "exp": iat + 300, "aud": "/admin/"}).encode()).rstrip(b"=").decode()
56    signature_input = f"{header}.{payload}".encode()
57    secret_bytes = bytes.fromhex(secret)
58    sig = hmac.new(secret_bytes, signature_input, hashlib.sha256).digest()
59    signature = base64.urlsafe_b64encode(sig).rstrip(b"=").decode()
60    return f"{header}.{payload}.{signature}"
61
62def _admin_headers() -> dict:
63    return {"Authorization": f"Ghost {_generate_admin_jwt()}", "Content-Type": "application/json"}
64
65def create_post(title: str, html: str, status: str = "draft", tags: list = None) -> dict:
66    """Create a post via the Ghost Admin API."""
67    body = {
68        "posts": [{
69            "title": title,
70            "html": html,
71            "status": status,  # 'draft' or 'published'
72            "tags": [{"name": t} for t in (tags or [])]
73        }]
74    }
75    response = requests.post(
76        f"{GHOST_URL}/ghost/api/admin/posts/",
77        headers=_admin_headers(),
78        json=body
79    )
80    response.raise_for_status()
81    return response.json().get("posts", [{}])[0]
82
83def update_post(post_id: str, updated_at: str, **fields) -> dict:
84    """Update a Ghost post. updated_at is required for conflict detection."""
85    body = {"posts": [{"updated_at": updated_at, **fields}]}
86    response = requests.put(
87        f"{GHOST_URL}/ghost/api/admin/posts/{post_id}/",
88        headers=_admin_headers(),
89        json=body
90    )
91    response.raise_for_status()
92    return response.json().get("posts", [{}])[0]
93
94if __name__ == "__main__":
95    posts = get_posts(limit=5)
96    print(f"Latest {len(posts)} posts:")
97    for p in posts:
98        print(f"  {p['title']} ({p['slug']}) — {p['published_at']}")
99
100    tags = get_tags()
101    print(f"\nTags: {[t['name'] for t in tags]}")

1const express = require('express');
2const GhostContentAPI = require('@tryghost/content-api');
3const GhostAdminAPI = require('@tryghost/admin-api');
4
5const app = express();
6app.use(express.json());
7
8const GHOST_URL = process.env.GHOST_URL;
9const CONTENT_KEY = process.env.GHOST_CONTENT_API_KEY;
10const ADMIN_KEY = process.env.GHOST_ADMIN_API_KEY;
11
12const contentApi = new GhostContentAPI({
13  url: GHOST_URL,
14  key: CONTENT_KEY,
15  version: 'v5.0'
16});
17
18const adminApi = new GhostAdminAPI({
19  url: GHOST_URL,
20  key: ADMIN_KEY,
21  version: 'v5.0'
22});
23
24// GET /posts — list recent posts
25app.get('/posts', async (req, res) => {
26  try {
27    const posts = await contentApi.posts.browse({
28      limit: parseInt(req.query.limit) || 10,
29      include: 'tags,authors',
30      order: 'published_at desc'
31    });
32    res.json(posts);
33  } catch (err) {
34    res.status(500).json({ error: err.message });
35  }
36});
37
38// GET /posts/:slug — fetch a single post
39app.get('/posts/:slug', async (req, res) => {
40  try {
41    const post = await contentApi.posts.read(
42      { slug: req.params.slug },
43      { include: 'tags,authors' }
44    );
45    res.json(post);
46  } catch (err) {
47    if (err.response?.status === 404) {
48      return res.status(404).json({ error: 'Post not found' });
49    }
50    res.status(500).json({ error: err.message });
51  }
52});
53
54// GET /tags — list all tags
55app.get('/tags', async (req, res) => {
56  try {
57    const tags = await contentApi.tags.browse({ limit: 'all' });
58    res.json(tags);
59  } catch (err) {
60    res.status(500).json({ error: err.message });
61  }
62});
63
64// POST /admin/posts — create a new post
65app.post('/admin/posts', async (req, res) => {
66  const { title, html, status = 'draft', tags = [] } = req.body;
67  if (!title || !html) {
68    return res.status(400).json({ error: 'title and html are required' });
69  }
70  try {
71    const post = await adminApi.posts.add(
72      { title, html, status, tags: tags.map(name => ({ name })) },
73      { source: 'html' }
74    );
75    res.status(201).json(post);
76  } catch (err) {
77    res.status(500).json({ error: err.message });
78  }
79});
80
81app.listen(3000, '0.0.0.0', () => {
82  console.log('Ghost API server running on port 3000');
83});