openwriter 0.40.1 → 0.40.3

package/dist/plugins/x-api/dist/index.js

@@ -0,0 +1,368 @@
+/**
+ * X API plugin for OpenWriter.
+ * Registers routes for checking X connection status and posting tweets.
+ * Uses @xdevplatform/xdk with OAuth1 credentials from plugin config.
+ */
+import { Client, OAuth1 } from '@xdevplatform/xdk';
+import { join, extname } from 'path';
+import { readFileSync, existsSync } from 'fs';
+import sharp from 'sharp';
+import twitter from 'twitter-text';
+import { getServerBridge } from './server-bridge.js';
+const { parseTweet } = twitter;
+/** X Articles API base. Two-step: draft, then publish. */
+const X_API_BASE = 'https://api.x.com/2';
+/** Build the OAuth1 signer from plugin config / env. Returns null when any of
+ *  the four credentials is missing. Shared by the SDK client and the raw
+ *  Articles calls (which the SDK doesn't model). */
+function createOAuth1(config) {
+    const apiKey = config['api-key'] || process.env.X_API_KEY || '';
+    const apiSecret = config['api-secret'] || process.env.X_API_SECRET || '';
+    const accessToken = config['access-token'] || process.env.X_ACCESS_TOKEN || '';
+    const accessTokenSecret = config['access-token-secret'] || process.env.X_ACCESS_TOKEN_SECRET || '';
+    if (!apiKey || !apiSecret || !accessToken || !accessTokenSecret)
+        return null;
+    return new OAuth1({
+        apiKey,
+        apiSecret,
+        callback: 'oob',
+        accessToken,
+        accessTokenSecret,
+    });
+}
+function createXClient(config) {
+    const oauth1 = createOAuth1(config);
+    if (!oauth1)
+        return null;
+    return new Client({ oauth1 });
+}
+/** Make an OAuth1-signed JSON request to the X API. The SDK has no Articles
+ *  resource, so we sign + fetch directly. `buildRequestHeader` correctly
+ *  excludes a JSON body from the OAuth1 signature base string. */
+async function xApiFetch(oauth1, method, path, body) {
+    const url = `${X_API_BASE}${path}`;
+    const bodyStr = body ? JSON.stringify(body) : '';
+    const authHeader = await oauth1.buildRequestHeader(method, url, bodyStr);
+    const headers = { Authorization: authHeader };
+    if (body)
+        headers['Content-Type'] = 'application/json';
+    const res = await fetch(url, { method, headers, body: body ? bodyStr : undefined });
+    const data = await res.json().catch(() => ({}));
+    return { ok: res.ok, status: res.status, data };
+}
+const plugin = {
+    name: '@openwriter/plugin-x-api',
+    version: '0.1.0',
+    description: 'Post tweets from OpenWriter',
+    category: 'social-media',
+    configSchema: {
+        'api-key': { type: 'string', env: 'X_API_KEY', description: 'X API Key' },
+        'api-secret': { type: 'string', env: 'X_API_SECRET', description: 'X API Secret' },
+        'access-token': { type: 'string', env: 'X_ACCESS_TOKEN', description: 'X Access Token' },
+        'access-token-secret': { type: 'string', env: 'X_ACCESS_TOKEN_SECRET', description: 'X Access Token Secret' },
+    },
+    registerRoutes(ctx) {
+        // GET /api/x/status — check if plugin is configured + authenticated
+        ctx.app.get('/api/x/status', async (_req, res) => {
+            try {
+                const client = createXClient(ctx.config);
+                if (!client) {
+                    res.json({ connected: false });
+                    return;
+                }
+                const me = await client.users.getMe();
+                const username = me?.data?.username;
+                res.json({ connected: true, username: username || undefined });
+            }
+            catch (err) {
+                console.error('[X Plugin] Status check failed:', err.message);
+                res.json({ connected: false, error: err.message });
+            }
+        });
+        // POST /api/x/post — post a tweet (with optional media)
+        ctx.app.post('/api/x/post', async (req, res) => {
+            try {
+                const { text, replyTo, quoteTweetId, mediaIds } = req.body;
+                if ((!text || typeof text !== 'string') && (!Array.isArray(mediaIds) || mediaIds.length === 0)) {
+                    res.status(400).json({ success: false, error: 'text or mediaIds is required' });
+                    return;
+                }
+                if (mediaIds && (!Array.isArray(mediaIds) || mediaIds.length > 4)) {
+                    res.status(400).json({ success: false, error: 'mediaIds must be an array of 1-4 IDs' });
+                    return;
+                }
+                const client = createXClient(ctx.config);
+                if (!client) {
+                    res.status(400).json({ success: false, error: 'X API credentials not configured' });
+                    return;
+                }
+                const body = {};
+                if (text)
+                    body.text = text;
+                if (replyTo) {
+                    body.reply = { inReplyToTweetId: replyTo };
+                }
+                if (quoteTweetId) {
+                    body.quoteTweetId = quoteTweetId;
+                }
+                if (mediaIds && mediaIds.length > 0) {
+                    body.media = { media_ids: mediaIds };
+                }
+                const result = await client.posts.create(body);
+                const tweetId = result?.data?.id;
+                const tweetUrl = tweetId ? `https://x.com/i/status/${tweetId}` : undefined;
+                res.json({ success: true, tweetId, tweetUrl });
+            }
+            catch (err) {
+                const detail = err.data ? JSON.stringify(err.data) : err.message;
+                console.error('[X Plugin] Post failed:', detail);
+                res.status(500).json({ success: false, error: detail });
+            }
+        });
+        // POST /api/x/post-thread — post a full thread as a reply chain (with optional media per tweet)
+        ctx.app.post('/api/x/post-thread', async (req, res) => {
+            try {
+                const { tweets, replyTo } = req.body;
+                if (!Array.isArray(tweets) || tweets.length === 0) {
+                    res.status(400).json({ success: false, error: 'tweets must be a non-empty array' });
+                    return;
+                }
+                // Normalize: accept string[] or { text, mediaIds? }[]
+                const normalized = tweets.map((t) => typeof t === 'string' ? { text: t, mediaIds: undefined } : t);
+                // Validate character limits using X's weighted counting (emojis=2, URLs=23, CJK=2)
+                const CHAR_LIMIT = 25000;
+                const overLimit = normalized.map((t, i) => ({ i, len: parseTweet(t.text).weightedLength })).filter(x => x.len > CHAR_LIMIT);
+                if (overLimit.length > 0) {
+                    res.status(400).json({
+                        success: false,
+                        error: `${overLimit.length} tweet(s) exceed ${CHAR_LIMIT} chars: ${overLimit.map(x => `#${x.i + 1} (${x.len})`).join(', ')}`,
+                    });
+                    return;
+                }
+                // Validate mediaIds per tweet
+                for (let i = 0; i < normalized.length; i++) {
+                    const ids = normalized[i].mediaIds;
+                    if (ids && (!Array.isArray(ids) || ids.length > 4)) {
+                        res.status(400).json({ success: false, error: `Tweet ${i + 1}: mediaIds must be an array of 1-4 IDs` });
+                        return;
+                    }
+                }
+                const client = createXClient(ctx.config);
+                if (!client) {
+                    res.status(400).json({ success: false, error: 'X API credentials not configured' });
+                    return;
+                }
+                const postedTweets = [];
+                let previousTweetId = replyTo;
+                for (let i = 0; i < normalized.length; i++) {
+                    const { text, mediaIds } = normalized[i];
+                    const body = {};
+                    if (text)
+                        body.text = text;
+                    if (previousTweetId) {
+                        body.reply = { inReplyToTweetId: previousTweetId };
+                    }
+                    if (mediaIds && mediaIds.length > 0) {
+                        body.media = { media_ids: mediaIds };
+                    }
+                    const result = await client.posts.create(body);
+                    const tweetId = result?.data?.id;
+                    if (!tweetId) {
+                        res.status(500).json({
+                            success: false,
+                            postedTweets,
+                            failedAt: i,
+                            error: `Tweet ${i + 1} posted but no ID returned`,
+                        });
+                        return;
+                    }
+                    postedTweets.push({ index: i, tweetId, text });
+                    previousTweetId = tweetId;
+                }
+                // Build thread URL from first tweet
+                const firstTweetId = postedTweets[0]?.tweetId;
+                const threadUrl = firstTweetId ? `https://x.com/i/status/${firstTweetId}` : undefined;
+                console.log(`[X Plugin] Thread posted: ${postedTweets.length} tweets, ${threadUrl}`);
+                res.json({ success: true, postedTweets, threadUrl });
+            }
+            catch (err) {
+                console.error('[X Plugin] Post thread failed:', err.message);
+                res.status(500).json({ success: false, error: err.message });
+            }
+        });
+        // POST /api/x/upload-media — upload a local /_images/ file for tweet attachment
+        ctx.app.post('/api/x/upload-media', async (req, res) => {
+            try {
+                const { src } = req.body;
+                if (!src || typeof src !== 'string') {
+                    res.status(400).json({ success: false, error: 'src is required' });
+                    return;
+                }
+                // Security: only allow /_images/ paths, no traversal
+                if (!/^\/_images\/[^/\\]+$/.test(src)) {
+                    res.status(400).json({ success: false, error: 'Invalid image path — must be /_images/<filename>' });
+                    return;
+                }
+                const filename = src.replace('/_images/', '');
+                const filePath = join(ctx.dataDir, '_images', filename);
+                if (!existsSync(filePath)) {
+                    res.status(404).json({ success: false, error: `Image not found: ${filename}` });
+                    return;
+                }
+                const ext = extname(filename).toLowerCase();
+                const mimeMap = {
+                    '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+                    '.png': 'image/png', '.webp': 'image/webp',
+                    '.gif': 'image/jpeg', '.bmp': 'image/bmp',
+                    '.tiff': 'image/tiff', '.tif': 'image/tiff',
+                };
+                const mediaType = mimeMap[ext] || 'image/jpeg';
+                const client = createXClient(ctx.config);
+                if (!client) {
+                    res.status(400).json({ success: false, error: 'X API credentials not configured' });
+                    return;
+                }
+                let fileBuffer = readFileSync(filePath);
+                let uploadType = mediaType;
+                const origSize = fileBuffer.length;
+                // Compress large images or PNGs to JPEG to stay under X API limits
+                if (fileBuffer.length > 3 * 1024 * 1024 || ext === '.png') {
+                    fileBuffer = Buffer.from(await sharp(fileBuffer).jpeg({ quality: 85 }).toBuffer());
+                    uploadType = 'image/jpeg';
+                    console.log(`[X Plugin] Compressed ${filename}: ${(origSize / 1024 / 1024).toFixed(2)}MB → ${(fileBuffer.length / 1024 / 1024).toFixed(2)}MB`);
+                }
+                console.log(`[X Plugin] Uploading ${filename}: ${(fileBuffer.length / 1024 / 1024).toFixed(2)}MB, type: ${uploadType}`);
+                const mediaBase64 = fileBuffer.toString('base64');
+                const uploadResult = await client.media.upload({
+                    body: { media: mediaBase64, mediaCategory: 'tweet_image', mediaType: uploadType },
+                });
+                const mediaId = uploadResult?.data?.id
+                    || uploadResult?.media_id_string;
+                if (!mediaId) {
+                    res.status(500).json({ success: false, error: 'Upload succeeded but no media ID returned' });
+                    return;
+                }
+                console.log(`[X Plugin] Media uploaded: ${filename} → ${mediaId}`);
+                res.json({ success: true, mediaId });
+            }
+            catch (err) {
+                console.error('[X Plugin] Media upload failed:', err.message);
+                if (err.response) {
+                    try {
+                        const body = await err.response.text();
+                        console.error('[X Plugin] X API response:', err.response.status, body);
+                    }
+                    catch { /* ignore */ }
+                }
+                if (err.data)
+                    console.error('[X Plugin] Error data:', JSON.stringify(err.data));
+                console.error('[X Plugin] Full error:', JSON.stringify(err, Object.getOwnPropertyNames(err)));
+                res.status(500).json({ success: false, error: err.message });
+            }
+        });
+        // POST /api/x/post-article — publish the active document as a native X
+        // Article. Two-step X flow: draft, then publish. Reads the active server
+        // doc (same source the managed/publish path reads) and converts it to X's
+        // DraftJS content_state via the shared converter.
+        ctx.app.post('/api/x/post-article', async (_req, res) => {
+            try {
+                const oauth1 = createOAuth1(ctx.config);
+                if (!oauth1) {
+                    res.status(400).json({ success: false, error: 'X API credentials not configured' });
+                    return;
+                }
+                const bridge = await getServerBridge();
+                const doc = bridge.getDocument();
+                const title = (bridge.getTitle() || '').trim();
+                const metadata = bridge.getMetadata() || {};
+                if (!title || title === 'Untitled') {
+                    res.status(400).json({ success: false, error: 'Article needs a title before posting.' });
+                    return;
+                }
+                const contentState = bridge.tiptapToDraftjs(doc);
+                if (!contentState.blocks.some((b) => (b.text || '').trim().length > 0)) {
+                    res.status(400).json({ success: false, error: 'Article body is empty.' });
+                    return;
+                }
+                // Optional cover image — upload to X and attach as cover_media.
+                let coverMedia;
+                const coverSrc = metadata?.articleContext?.coverImage;
+                if (coverSrc && typeof coverSrc === 'string' && /^\/_images\/[^/\\]+$/.test(coverSrc)) {
+                    const client = createXClient(ctx.config);
+                    if (client) {
+                        const mediaId = await uploadCoverMedia(client, ctx.dataDir, coverSrc);
+                        if (mediaId)
+                            coverMedia = { media_category: 'TWEET_IMAGE', media_id: mediaId };
+                    }
+                }
+                // Step 1 — create the draft.
+                const draftBody = { title, content_state: contentState };
+                if (coverMedia)
+                    draftBody.cover_media = coverMedia;
+                const draft = await xApiFetch(oauth1, 'POST', '/articles/draft', draftBody);
+                if (!draft.ok) {
+                    const detail = draft.data?.detail || draft.data?.title || JSON.stringify(draft.data);
+                    console.error('[X Plugin] Article draft failed:', draft.status, detail);
+                    res.status(draft.status || 500).json({ success: false, error: `Draft failed: ${detail}` });
+                    return;
+                }
+                const articleId = draft.data?.data?.id;
+                if (!articleId) {
+                    res.status(500).json({ success: false, error: 'Draft created but no article id returned.' });
+                    return;
+                }
+                // Step 2 — publish the draft (makes it public). Surface any error
+                // verbatim — a draft is private until this succeeds.
+                const published = await xApiFetch(oauth1, 'POST', `/articles/${articleId}/publish`);
+                if (!published.ok) {
+                    const detail = published.data?.detail || published.data?.title || JSON.stringify(published.data);
+                    console.error('[X Plugin] Article publish failed:', published.status, detail);
+                    res.status(published.status || 500).json({ success: false, articleId, error: `Publish failed: ${detail}` });
+                    return;
+                }
+                const postId = published.data?.data?.post_id;
+                const articleUrl = postId ? `https://x.com/i/status/${postId}` : undefined;
+                console.log(`[X Plugin] Article published: ${articleId} -> ${articleUrl}`);
+                res.json({ success: true, articleId, postId, articleUrl });
+            }
+            catch (err) {
+                const detail = err.data ? JSON.stringify(err.data) : err.message;
+                console.error('[X Plugin] Post article failed:', detail);
+                res.status(500).json({ success: false, error: detail });
+            }
+        });
+    },
+};
+/** Upload an article cover image to X, returning its media_id. Mirrors the
+ *  /api/x/upload-media compression rules (>3MB or PNG -> JPEG). Returns null on
+ *  any failure — the article still posts, just without a cover. */
+async function uploadCoverMedia(client, dataDir, src) {
+    try {
+        const filename = src.replace('/_images/', '');
+        const filePath = join(dataDir, '_images', filename);
+        if (!existsSync(filePath))
+            return null;
+        const ext = extname(filename).toLowerCase();
+        const mimeMap = {
+            '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+            '.png': 'image/png', '.webp': 'image/webp',
+            '.gif': 'image/jpeg', '.bmp': 'image/bmp',
+            '.tiff': 'image/tiff', '.tif': 'image/tiff',
+        };
+        let fileBuffer = readFileSync(filePath);
+        let uploadType = mimeMap[ext] || 'image/jpeg';
+        if (fileBuffer.length > 3 * 1024 * 1024 || ext === '.png') {
+            fileBuffer = Buffer.from(await sharp(fileBuffer).jpeg({ quality: 85 }).toBuffer());
+            uploadType = 'image/jpeg';
+        }
+        const uploadResult = await client.media.upload({
+            body: { media: fileBuffer.toString('base64'), mediaCategory: 'tweet_image', mediaType: uploadType },
+        });
+        return uploadResult?.data?.id || uploadResult?.media_id_string || null;
+    }
+    catch (err) {
+        console.error('[X Plugin] Cover upload failed:', err.message);
+        return null;
+    }
+}
+export default plugin;

package/dist/plugins/x-api/dist/server-bridge.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Thin runtime bridge to the OpenWriter server modules this plugin needs for
+ * article publishing — the active document, its title/metadata, the data dir,
+ * and the shared TipTap -> DraftJS converter.
+ *
+ * The converter (server/tiptap-draftjs.ts) is shared with plugins/publish so
+ * both posting paths produce identical X content_state. We import the compiled
+ * server module at runtime rather than vendoring it, resolving both the npm
+ * package layout and the monorepo layout — the same dual-path trick the publish
+ * plugin's helpers use.
+ */
+export interface ServerBridge {
+    getDocument: () => any;
+    getTitle: () => string;
+    getMetadata: () => Record<string, any>;
+    getDataDir: () => string;
+    tiptapToDraftjs: (doc: any) => {
+        blocks: any[];
+        entities: any[];
+    };
+}
+export declare function getServerBridge(): Promise<ServerBridge>;

package/dist/plugins/x-api/dist/server-bridge.js

@@ -0,0 +1,43 @@
+/**
+ * Thin runtime bridge to the OpenWriter server modules this plugin needs for
+ * article publishing — the active document, its title/metadata, the data dir,
+ * and the shared TipTap -> DraftJS converter.
+ *
+ * The converter (server/tiptap-draftjs.ts) is shared with plugins/publish so
+ * both posting paths produce identical X content_state. We import the compiled
+ * server module at runtime rather than vendoring it, resolving both the npm
+ * package layout and the monorepo layout — the same dual-path trick the publish
+ * plugin's helpers use.
+ */
+// npm package: dist/plugins/x-api/dist/server-bridge.js -> dist/server/
+// monorepo:    plugins/x-api/dist/server-bridge.js      -> packages/openwriter/dist/server/
+const npmBase = new URL('../../../server/', import.meta.url).href;
+const monoBase = new URL('../../../packages/openwriter/dist/server/', import.meta.url).href;
+let cached = null;
+async function tryImport(base) {
+    const [state, helpers, draftjs] = await Promise.all([
+        import(base + 'state.js'),
+        import(base + 'helpers.js'),
+        import(base + 'tiptap-draftjs.js'),
+    ]);
+    return { state, helpers, draftjs };
+}
+export async function getServerBridge() {
+    if (cached)
+        return cached;
+    let state, helpers, draftjs;
+    try {
+        ({ state, helpers, draftjs } = await tryImport(npmBase));
+    }
+    catch {
+        ({ state, helpers, draftjs } = await tryImport(monoBase));
+    }
+    cached = {
+        getDocument: state.getDocument,
+        getTitle: state.getTitle,
+        getMetadata: state.getMetadata,
+        getDataDir: helpers.getDataDir,
+        tiptapToDraftjs: draftjs.tiptapToDraftjs,
+    };
+    return cached;
+}

package/dist/plugins/x-api/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@openwriter/plugin-x-api",
+  "version": "0.1.0",
+  "description": "Post tweets from OpenWriter",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {
+    "@xdevplatform/xdk": "^0.4.0",
+    "twitter-text": "^3.1.0"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.0",
+    "typescript": "^5.6.0"
+  },
+  "openwriter": {
+    "displayName": "X / Twitter",
+    "category": "social-media"
+  },
+  "files": [
+    "dist/",
+    "package.json"
+  ]
+}

package/dist/server/blog-routes.js

@@ -0,0 +1,160 @@
+/**
+ * Blog publishing routes — push blog content to GitHub via platform connection.
+ * Builds clean YAML frontmatter + markdown body, collects images, posts to platform.
+ */
+import { Router } from 'express';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import matter from 'gray-matter';
+import { getDocument, getTitle, getMetadata, save, cancelDebouncedSave } from './state.js';
+import { tiptapToMarkdown } from './markdown.js';
+import { platformFetch, isAuthenticated } from './connections.js';
+import { getDataDir } from './helpers.js';
+export function createBlogRouter() {
+    const router = Router();
+    // Find active GitHub connection for blog publishing
+    router.get('/api/blog/connection', async (_req, res) => {
+        try {
+            if (!isAuthenticated()) {
+                res.json({ connection: null });
+                return;
+            }
+            const upstream = await platformFetch('/connections/unified');
+            if (!upstream.ok) {
+                res.json({ connection: null });
+                return;
+            }
+            const data = await upstream.json();
+            const ghConn = data.connections?.find((c) => c.provider === 'github' && c.status === 'active');
+            res.json({ connection: ghConn || null });
+        }
+        catch {
+            res.json({ connection: null });
+        }
+    });
+    // Publish blog post to GitHub via platform connection
+    router.post('/api/blog/publish', async (req, res) => {
+        try {
+            if (!isAuthenticated()) {
+                res.status(401).json({ error: 'Not authenticated' });
+                return;
+            }
+            // Flush current doc to disk
+            cancelDebouncedSave();
+            save();
+            const doc = getDocument();
+            const title = getTitle();
+            const metadata = getMetadata();
+            const blogCtx = metadata.blogContext;
+            if (!blogCtx?.active) {
+                res.status(400).json({ error: 'Not a blog document' });
+                return;
+            }
+            // Get clean markdown body (strip OpenWriter JSON frontmatter)
+            const fullMd = tiptapToMarkdown(doc, title, metadata);
+            const parsed = matter(fullMd);
+            let markdownBody = parsed.content.trim();
+            // Build clean blog YAML frontmatter — only include fields the target schema expects
+            const fm = {
+                title,
+                description: blogCtx.description || '',
+                date: blogCtx.date || new Date().toISOString().split('T')[0],
+            };
+            // Optional fields — only include if explicitly set
+            if (blogCtx.author)
+                fm.author = blogCtx.author;
+            if (blogCtx.layout)
+                fm.layout = blogCtx.layout;
+            if (blogCtx.category)
+                fm.category = blogCtx.category;
+            if (blogCtx.tags?.length)
+                fm.tags = blogCtx.tags;
+            if (blogCtx.draft)
+                fm.draft = true;
+            // Find GitHub connection
+            const connectionId = req.body.connectionId;
+            const connRes = await platformFetch('/connections/unified');
+            if (!connRes.ok) {
+                res.status(500).json({ error: 'Failed to fetch connections' });
+                return;
+            }
+            const connData = await connRes.json();
+            const ghConn = connectionId
+                ? connData.connections?.find((c) => c.id === connectionId)
+                : connData.connections?.find((c) => c.provider === 'github' && c.status === 'active');
+            if (!ghConn) {
+                res.status(400).json({ error: 'No GitHub connection found. Connect a GitHub repo first.' });
+                return;
+            }
+            // Fetch connection config to derive image web path
+            let imageWebPrefix = '/images';
+            try {
+                const cfgRes = await platformFetch(`/connections/${ghConn.id}/config`);
+                if (cfgRes.ok) {
+                    const cfg = await cfgRes.json();
+                    const imgDir = cfg.config?.imageDir || cfg.imageDir;
+                    if (imgDir) {
+                        imageWebPrefix = '/' + imgDir.replace(/^public\/?/, '');
+                    }
+                }
+            }
+            catch { /* fall back to /images */ }
+            // Cover image — read as base64 for GitHub commit
+            let imageBase64;
+            let imageFilename;
+            if (blogCtx.coverImage) {
+                const imgPath = blogCtx.coverImage.replace(/^\/_images\//, '');
+                const fullImgPath = join(getDataDir(), '_images', imgPath);
+                if (existsSync(fullImgPath)) {
+                    imageBase64 = readFileSync(fullImgPath).toString('base64');
+                    imageFilename = imgPath;
+                    fm.image = `${imageWebPrefix}/${imgPath}`;
+                }
+            }
+            // Collect inline images and rewrite paths in markdown
+            const inlineImages = [];
+            const imgRegex = /!\[([^\]]*)\]\(\/_images\/([^)]+)\)/g;
+            markdownBody = markdownBody.replace(imgRegex, (_match, alt, imgFile) => {
+                const fullImgPath = join(getDataDir(), '_images', imgFile);
+                if (existsSync(fullImgPath)) {
+                    inlineImages.push({ filename: imgFile, base64: readFileSync(fullImgPath).toString('base64') });
+                }
+                return `![${alt}](${imageWebPrefix}/${imgFile})`;
+            });
+            // Assemble full markdown with YAML frontmatter
+            const yamlLines = Object.entries(fm).map(([k, v]) => {
+                if (Array.isArray(v))
+                    return `${k}:\n${v.map(i => `  - ${JSON.stringify(i)}`).join('\n')}`;
+                if (typeof v === 'boolean')
+                    return `${k}: ${v}`;
+                return `${k}: ${JSON.stringify(v)}`;
+            });
+            const fullMarkdown = `---\n${yamlLines.join('\n')}\n---\n\n${markdownBody}`;
+            // Build target filename from slug or title
+            const slug = blogCtx.slug || title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+            const filename = `${slug}.md`;
+            // Post to platform — matches worker's expected payload:
+            // { markdown, filename, imageBase64?, imageFilename?, commitMessage? }
+            const upstream = await platformFetch(`/connections/${ghConn.id}/post`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    markdown: fullMarkdown,
+                    filename,
+                    ...(imageBase64 && imageFilename ? { imageBase64, imageFilename } : {}),
+                    ...(inlineImages.length ? { images: inlineImages } : {}),
+                    commitMessage: `Add blog post: ${title}`,
+                }),
+            });
+            const result = await upstream.json();
+            if (!upstream.ok) {
+                res.status(upstream.status).json(result);
+                return;
+            }
+            res.json({ success: true, ...result });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    return router;
+}