openwriter 0.6.11 → 0.8.0

package/dist/plugins/publish/dist/index.js

@@ -1,5 +1,7 @@
 import { getServerModules, publishFetch } from './helpers.js';
 import { newsletterTools } from './newsletter-tools.js';
+import { readFileSync, existsSync } from 'fs';
+import { join, extname } from 'path';
 const plugin = {
     name: '@openwriter/plugin-publish',
     version: '0.1.0',
@@ -332,33 +334,166 @@ const plugin = {
             // --- Scheduler tools ---
             {
                 name: 'schedule_post',
-                description: 'Schedule content for posting. Modes: queue (next available slot), now (immediate), custom (specific time).',
+                description: 'Schedule the current document for posting. Reads content and content_type from the active document automatically. Default mode: queue (next available slot).',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        content: { type: 'string', description: 'Post content' },
-                        connection_id: { type: 'string', description: 'Target connection ID (use list_connections to find)' },
-                        content_type: { type: 'string', enum: ['tweet', 'x', 'linkedin', 'newsletter'], description: 'Content type' },
+                        connection_id: { type: 'string', description: 'Target connection ID (use list_connections to find). If omitted, infers from content_type.' },
                         mode: { type: 'string', enum: ['queue', 'now', 'custom'], description: 'Scheduling mode (default: queue)' },
                         scheduled_at: { type: 'string', description: 'ISO datetime for custom mode' },
+                        slot_id: { type: 'string', description: 'Specific slot ID to target (overrides automatic slot selection)' },
                     },
-                    required: ['content', 'content_type'],
                 },
                 handler: async (params) => {
+                    const server = await getServerModules();
+                    const doc = server.getDocument();
+                    const metadata = server.getMetadata();
+                    const docId = server.getDocId();
+                    if (!doc || !doc.content)
+                        return { error: 'No active document. Switch to a document first.' };
+                    // --- Helpers ---
+                    const extractText = (nodes) => {
+                        const walk = (node) => {
+                            if (node.type === 'text')
+                                return node.text || '';
+                            if (node.type === 'hardBreak')
+                                return '\n';
+                            if (!node.content)
+                                return '';
+                            const inner = node.content.map(walk).join('');
+                            if (node.type === 'paragraph')
+                                return inner + '\n\n';
+                            return inner;
+                        };
+                        return nodes.map(walk).join('').trim();
+                    };
+                    const extractImages = (nodes) => {
+                        const srcs = [];
+                        const walk = (node) => {
+                            if (node.type === 'image' && node.attrs?.src)
+                                srcs.push(node.attrs.src);
+                            if (node.content)
+                                node.content.forEach(walk);
+                        };
+                        nodes.forEach(walk);
+                        return srcs.slice(0, 4); // X limit: 4 images per tweet
+                    };
+                    const mimeMap = {
+                        '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+                        '.png': 'image/png', '.webp': 'image/webp',
+                        '.gif': 'image/gif', '.bmp': 'image/bmp',
+                    };
+                    const uploadImages = async (srcs, connId) => {
+                        const ids = [];
+                        const dataDir = server.getDataDir();
+                        for (const src of srcs) {
+                            if (!src.startsWith('/_images/'))
+                                continue;
+                            const filename = src.replace('/_images/', '');
+                            const filePath = join(dataDir, '_images', filename);
+                            if (!existsSync(filePath))
+                                continue;
+                            const ext = extname(filename).toLowerCase();
+                            const mediaType = mimeMap[ext] || 'image/jpeg';
+                            const mediaBase64 = readFileSync(filePath).toString('base64');
+                            const res = await server.platformFetch(`/connections/${connId}/upload-media`, {
+                                method: 'POST',
+                                body: JSON.stringify({ media_base64: mediaBase64, media_type: mediaType }),
+                            });
+                            if (res.ok) {
+                                const data = await res.json();
+                                if (data.mediaId)
+                                    ids.push(data.mediaId);
+                            }
+                        }
+                        return ids;
+                    };
+                    // --- Split doc at horizontalRule nodes (thread detection) ---
+                    const docNodes = doc.content || [];
+                    const tweetGroups = [[]];
+                    for (const node of docNodes) {
+                        if (node.type === 'horizontalRule') {
+                            tweetGroups.push([]);
+                        }
+                        else {
+                            tweetGroups[tweetGroups.length - 1].push(node);
+                        }
+                    }
+                    // Filter empty groups
+                    const tweets = tweetGroups.filter(g => g.length > 0);
+                    const isThread = tweets.length > 1;
+                    // Derive content_type from metadata
+                    const contentType = metadata?.content_type || 'tweet';
+                    // Auto-find connection
+                    let connectionId = params.connection_id;
+                    if (!connectionId) {
+                        const provider = contentType === 'linkedin' ? 'linkedin' : 'x';
+                        const listRes = await server.platformFetch('/connections');
+                        if (listRes.ok) {
+                            const data = await listRes.json();
+                            const conn = data.connections.find((c) => c.provider === provider && c.status === 'active');
+                            if (conn)
+                                connectionId = conn.id;
+                        }
+                        if (!connectionId)
+                            return { error: `No active ${provider} connection found.` };
+                    }
+                    // --- Build content: single tweet or thread ---
+                    let queueContent;
+                    let totalMedia = 0;
+                    if (isThread) {
+                        const tweetData = [];
+                        for (const group of tweets) {
+                            const text = extractText(group);
+                            if (!text)
+                                continue;
+                            const images = extractImages(group);
+                            const mediaIds = images.length > 0 ? await uploadImages(images, connectionId) : [];
+                            totalMedia += mediaIds.length;
+                            tweetData.push(mediaIds.length > 0 ? { text, mediaIds } : { text });
+                        }
+                        if (tweetData.length === 0)
+                            return { error: 'Document is empty.' };
+                        queueContent = { tweets: tweetData };
+                    }
+                    else {
+                        const text = extractText(docNodes);
+                        if (!text)
+                            return { error: 'Document is empty.' };
+                        const images = extractImages(docNodes);
+                        const mediaIds = images.length > 0 ? await uploadImages(images, connectionId) : [];
+                        totalMedia = mediaIds.length;
+                        queueContent = mediaIds.length > 0 ? { text, mediaIds } : { text };
+                    }
+                    // --- Queue it ---
+                    const body = {
+                        content: queueContent,
+                        content_type: isThread ? 'thread' : contentType,
+                        connection_id: connectionId,
+                        mode: params.mode || 'queue',
+                        doc_id: docId,
+                    };
+                    if (params.scheduled_at)
+                        body.scheduled_at = params.scheduled_at;
+                    if (params.slot_id)
+                        body.slot_id = params.slot_id;
                     const res = await publishFetch(config, '/scheduler/queue', {
                         method: 'POST',
-                        body: JSON.stringify({
-                            content: params.content,
-                            content_type: params.content_type,
-                            connection_id: params.connection_id,
-                            mode: params.mode || 'queue',
-                            scheduled_at: params.scheduled_at,
-                        }),
+                        body: JSON.stringify(body),
                     });
                     const data = await res.json();
                     if (!res.ok)
                         return { error: `Schedule failed: ${data.error || res.statusText}` };
-                    return { success: true, item: data.item, message: `Content scheduled for ${data.item?.scheduled_at}` };
+                    return {
+                        success: true,
+                        docId,
+                        scheduled_at: data.item?.scheduled_at,
+                        connection: connectionId,
+                        mode: params.mode || 'queue',
+                        type: isThread ? 'thread' : 'tweet',
+                        tweetCount: isThread ? tweets.length : 1,
+                        mediaCount: totalMedia,
+                    };
                 },
             },
             {
@@ -691,6 +826,102 @@ const plugin = {
                     return { success: true, ...data };
                 },
             },
+            {
+                name: 'naturalize_slots',
+                description: 'Scramble slot times so posts don\'t look scheduled. Splits multi-day slots into per-day slots with jittered times (+/- 15 min). Each day gets a slightly different minute offset. Run after creating slots at clean macro times.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        jitter_minutes: { type: 'number', description: 'Max jitter in minutes (default: 15). Each slot shifts by a random amount within this range.' },
+                    },
+                },
+                handler: async (params) => {
+                    const jitter = params.jitter_minutes || 15;
+                    const ALL_DAYS = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'];
+                    // Fetch current slots
+                    const listRes = await publishFetch(config, '/scheduler/slots');
+                    const listData = await listRes.json();
+                    if (!listRes.ok)
+                        return { error: `Failed to list slots: ${listData.error || listRes.statusText}` };
+                    const slots = listData.slots || [];
+                    if (!slots.length)
+                        return { error: 'No slots to naturalize' };
+                    // Parse HH:MM:SS or HH:MM to total minutes
+                    const parseTime = (t) => {
+                        const [h, m] = t.split(':').map(Number);
+                        return h * 60 + m;
+                    };
+                    // Format total minutes back to HH:MM
+                    const formatTime = (mins) => {
+                        const clamped = ((mins % 1440) + 1440) % 1440;
+                        const h = Math.floor(clamped / 60);
+                        const m = clamped % 60;
+                        return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}`;
+                    };
+                    // Deterministic-ish jitter per day index and slot index
+                    const jitterFor = (dayIdx, slotIdx) => {
+                        const seed = (dayIdx * 7 + slotIdx * 13 + 3) % (jitter * 2 + 1);
+                        return seed - jitter;
+                    };
+                    let created = 0;
+                    let deleted = 0;
+                    const results = [];
+                    for (let si = 0; si < slots.length; si++) {
+                        const slot = slots[si];
+                        const days = slot.days || ['default'];
+                        const expandedDays = days.includes('default') ? ALL_DAYS : days;
+                        // Skip already single-day slots (already naturalized)
+                        if (expandedDays.length === 1 && !days.includes('default')) {
+                            // Still jitter the time if it's on a round number
+                            const mins = parseTime(slot.time);
+                            if (mins % 5 === 0) {
+                                const dayIdx = ALL_DAYS.indexOf(expandedDays[0]);
+                                const newMins = mins + jitterFor(dayIdx, si);
+                                const editRes = await publishFetch(config, `/scheduler/slots/${slot.id}`, {
+                                    method: 'PATCH',
+                                    body: JSON.stringify({ time: formatTime(newMins) }),
+                                });
+                                if (editRes.ok) {
+                                    results.push(`${expandedDays[0]}: ${slot.time} → ${formatTime(newMins)}`);
+                                }
+                            }
+                            continue;
+                        }
+                        // Multi-day slot: delete and create per-day replacements
+                        const baseMinutes = parseTime(slot.time);
+                        const delRes = await publishFetch(config, `/scheduler/slots/${slot.id}`, { method: 'DELETE' });
+                        if (delRes.ok)
+                            deleted++;
+                        for (let di = 0; di < expandedDays.length; di++) {
+                            const day = expandedDays[di];
+                            const dayIdx = ALL_DAYS.indexOf(day);
+                            const offset = jitterFor(dayIdx, si);
+                            const newTime = formatTime(baseMinutes + offset);
+                            const createRes = await publishFetch(config, '/scheduler/slots', {
+                                method: 'POST',
+                                body: JSON.stringify({
+                                    time: newTime,
+                                    days: [day],
+                                    filter_type: slot.filter_type || 'any',
+                                    filter_value: slot.filter_value || null,
+                                    timezone: slot.timezone || 'America/Los_Angeles',
+                                }),
+                            });
+                            if (createRes.ok) {
+                                created++;
+                                results.push(`${day}: ${slot.time} → ${newTime}`);
+                            }
+                        }
+                    }
+                    return {
+                        success: true,
+                        deleted,
+                        created,
+                        summary: `Naturalized ${deleted} multi-day slots into ${created} per-day slots`,
+                        details: results,
+                    };
+                },
+            },
         ];
     },
 };

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

@@ -6,6 +6,8 @@
 import { Client, OAuth1 } from '@xdevplatform/xdk';
 import { join, extname } from 'path';
 import { readFileSync, existsSync } from 'fs';
+import twitter from 'twitter-text';
+const { parseTweet } = twitter;
 function createXClient(config) {
     const apiKey = config['api-key'] || process.env.X_API_KEY || '';
     const apiSecret = config['api-secret'] || process.env.X_API_SECRET || '';
@@ -101,9 +103,9 @@ const plugin = {
                 }
                 // Normalize: accept string[] or { text, mediaIds? }[]
                 const normalized = tweets.map((t) => typeof t === 'string' ? { text: t, mediaIds: undefined } : t);
-                // Validate character limits (X API v2 supports up to 25k chars for Premium accounts)
+                // 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: t.text.length })).filter(x => x.len > CHAR_LIMIT);
+                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,

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

@@ -9,7 +9,8 @@
     "dev": "tsc --watch"
   },
   "dependencies": {
-    "@xdevplatform/xdk": "^0.4.0"
+    "@xdevplatform/xdk": "^0.4.0",
+    "twitter-text": "^3.1.0"
   },
   "devDependencies": {
     "@types/express": "^5.0.0",

package/dist/server/compact.js

@@ -177,7 +177,7 @@ function nodeToCompactLines(node, indent) {
     lines.push(`${indent}${tag} ${text}`);
     return lines;
 }
-export function toCompactFormat(doc, title, wordCount, pendingCount, docId) {
+export function toCompactFormat(doc, title, wordCount, pendingCount, docId, metadata) {
     const header = [
         `title: ${title}`,
         ...(docId ? [`id: ${docId}`] : []),
@@ -185,12 +185,50 @@ export function toCompactFormat(doc, title, wordCount, pendingCount, docId) {
         `pending: ${pendingCount}`,
         '---',
     ];
+    const isTweet = !!metadata?.tweetContext;
     const body = [];
     for (const node of doc.content || []) {
         body.push(...nodeToCompactLines(node, ''));
+        // Show char count after each tweet paragraph in a thread
+        if (isTweet && node.type === 'paragraph' && node.attrs?.id) {
+            const text = extractNodeText(node);
+            if (text.trim()) {
+                const chars = tweetWeightedLength(text);
+                const over = chars - 280;
+                body.push(over > 0 ? `  ⚠ ${chars}/280 (+${over})` : `  ✓ ${chars}/280`);
+            }
+        }
     }
     return [...header, ...body].join('\n');
 }
+/** Extract plain text from a node tree. */
+function extractNodeText(node) {
+    if (!node)
+        return '';
+    if (node.type === 'text' && typeof node.text === 'string')
+        return node.text;
+    if (node.type === 'hardBreak')
+        return '\n';
+    if (node.content)
+        return node.content.map(extractNodeText).join('');
+    return '';
+}
+/** X-weighted char count using twitter-text. */
+let _parseTweet = null;
+function tweetWeightedLength(text) {
+    if (!_parseTweet) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const twitter = require('twitter-text');
+            _parseTweet = twitter.parseTweet || twitter.default?.parseTweet;
+        }
+        catch {
+            // Fallback: plain char count
+            return text.length;
+        }
+    }
+    return _parseTweet(text).weightedLength;
+}
 /**
  * Convert an array of TipTap nodes to compact tagged-line format.
  * Used by get_nodes tool.

package/dist/server/connection-routes.js

@@ -61,7 +61,14 @@ export function createConnectionRouter() {
     router.delete('/api/connections/:id', async (req, res) => {
         try {
             const upstream = await platformFetch(`/connections/${req.params.id}`, { method: 'DELETE' });
-            const data = await upstream.json();
+            const text = await upstream.text();
+            let data;
+            try {
+                data = JSON.parse(text);
+            }
+            catch {
+                data = { error: text };
+            }
             if (!upstream.ok) {
                 res.status(upstream.status).json(data);
                 return;

package/dist/server/index.js

@@ -12,6 +12,7 @@ import { TOOL_REGISTRY } from './mcp.js';
 import { z } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 import { save, cancelDebouncedSave, load, getDocument, getTitle, getFilePath, getDocId, getMetadata, getStatus, updateDocument, setMetadata, applyTextEdits, isAgentLocked, getPendingDocInfo, getDocTagsByFilename, addDocTag, removeDocTag, markAllNodesAsPending, updatePendingCacheForActiveDoc, clearAllCaches } from './state.js';
+import { syncPostHistory } from './post-sync.js';
 import { listDocuments, switchDocument, createDocument, deleteDocument, duplicateDocument, reloadDocument, updateDocumentTitle, openFile, reorderDocs, searchDocuments, listArchivedDocuments, archiveDocument, unarchiveDocument, getActiveFilename } from './documents.js';
 import { createWorkspaceRouter } from './workspace-routes.js';
 import { createLinkRouter } from './link-routes.js';
@@ -732,6 +733,8 @@ export async function startHttpServer(options = {}) {
             resolve();
         });
     });
+    // Sync post history from platform (catch posts made while app was closed)
+    syncPostHistory().catch(() => { });
     // Open browser unless --no-open or running as MCP stdio pipe
     const isMcpStdio = !process.stdout.isTTY;
     if (!options.noOpen && !isMcpStdio) {