npm - openwriter - Versions diffs - 0.6.11 → 0.7.0 - Mend

openwriter 0.6.11 → 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/dist/client/assets/index-BhlEJsdX.css +1 -0
package/dist/client/assets/index-XajWsVLO.js +210 -0
package/dist/client/index.html +2 -2
package/dist/plugins/publish/dist/index.js +244 -13
package/dist/server/connection-routes.js +8 -1
package/dist/server/index.js +3 -0
package/dist/server/mcp.js +43 -20
package/dist/server/post-sync.js +114 -0
package/dist/server/scheduler-routes.js +33 -0
package/dist/server/workspaces.js +35 -0
package/package.json +1 -1
package/skill/SKILL.md +15 -3
package/dist/client/assets/index-BFXmrfky.js +0 -210
package/dist/client/assets/index-DnndZMJ9.css +0 -1

package/dist/client/index.html CHANGED Viewed

@@ -10,8 +10,8 @@
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=Charter:ital,wght@0,400;0,700;1,400&family=Crimson+Pro:ital,wght@0,300;0,400;0,600;0,700;1,400&family=DM+Sans:ital,wght@0,400;0,500;0,600;0,700;1,400&family=DM+Serif+Display&family=IBM+Plex+Mono:wght@400;500;600&family=IBM+Plex+Sans:wght@400;500;600&family=Inter:wght@400;500;600;700&family=Libre+Baskerville:ital,wght@0,400;0,700;1,400&family=Literata:ital,opsz,wght@0,7..72,400;0,7..72,600;0,7..72,700;1,7..72,400&family=Newsreader:ital,opsz,wght@0,6..72,400;0,6..72,600;1,6..72,400&family=Playfair+Display:wght@400;600;700;900&family=Source+Serif+4:ital,opsz,wght@0,8..60,400;0,8..60,600;0,8..60,700;1,8..60,400&family=Space+Grotesk:wght@400;500;600;700&family=Space+Mono:wght@400;700&display=swap" rel="stylesheet" />
-    <script type="module" crossorigin src="/assets/index-BFXmrfky.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DnndZMJ9.css">
+    <script type="module" crossorigin src="/assets/index-XajWsVLO.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BhlEJsdX.css">
   </head>
   <body>
     <div id="root"></div>

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

@@ -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/server/connection-routes.js CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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) {

package/dist/server/mcp.js CHANGED Viewed

@@ -13,7 +13,7 @@ import { getDataDir, ensureDataDir, resolveDocPath, generateNodeId } from './hel
 import { getDocument, getWordCount, getPendingChangeCount, getTitle, getStatus, getNodesByIds, getMetadata, setMetadata, applyChanges, applyTextEdits, updateDocument, save, markAllNodesAsPending, setAgentLock, updatePendingCacheForActiveDoc, populateDocumentFile, applyChangesToFile, applyTextEditsToFile, getDocId, getFilePath, } from './state.js';
 import { listDocuments, switchDocument, createDocument, createDocumentFile, deleteDocument, openFile, getActiveFilename, updateDocumentTitle, promoteTempFile, archiveDocument, unarchiveDocument, resolveDocId } from './documents.js';
 import { broadcastDocumentSwitched, broadcastDocumentsChanged, broadcastWorkspacesChanged, broadcastTitleChanged, broadcastMetadataChanged, broadcastPendingDocsChanged, broadcastWritingStarted, broadcastWritingFinished } from './ws.js';
-import { listWorkspaces, getWorkspace, getDocTitle, getItemContext, addDoc, updateWorkspaceContext, createWorkspace, deleteWorkspace, addContainerToWorkspace, findOrCreateWorkspace, findOrCreateContainer, moveDoc, removeContainer, renameWorkspace, renameContainer } from './workspaces.js';
+import { listWorkspaces, getWorkspace, getDocTitle, getItemContext, addDoc, updateWorkspaceContext, createWorkspace, deleteWorkspace, addContainerToWorkspace, findOrCreateWorkspace, findOrCreateContainer, moveDoc, moveContainer, reorderWorkspaceAfter, removeContainer, renameWorkspace, renameContainer } from './workspaces.js';
 import { addDocTag, removeDocTag, getDocTagsByFilename, getCachedDocument } from './state.js';
 import { findDocNode } from './workspace-tree.js';
 import { importGoogleDoc } from './gdoc-import.js';
@@ -618,28 +618,51 @@ export const TOOL_REGISTRY = [
         },
     },
     {
-        name: 'move_doc',
-        description: 'Add a document to a workspace, or move it within the workspace. If the doc is not yet in the workspace it will be added; if it is already present it will be moved to the target container.',
+        name: 'move_item',
+        description: 'Move or reorder a doc, container, or workspace. For docs: add to workspace or move within it. For containers: move to different parent or reorder within current parent. For workspaces: reorder in sidebar.',
         schema: {
-            workspaceFile: z.string().describe('Workspace manifest filename'),
-            docId: z.string().describe('Document docId (8-char hex from list_documents)'),
-            targetContainerId: z.string().optional().describe('Target container ID (omit for root level)'),
-            afterFile: z.string().optional().describe('Place after this file (omit for beginning)'),
-        },
-        handler: async ({ workspaceFile, docId, targetContainerId, afterFile }) => {
-            const filename = resolveDocId(docId);
-            const ws = getWorkspace(workspaceFile);
-            const existing = findDocNode(ws.root, filename);
-            if (existing) {
-                moveDoc(workspaceFile, filename, targetContainerId ?? null, afterFile ?? null);
+            type: z.enum(['doc', 'container', 'workspace']).describe('What to move'),
+            workspaceFile: z.string().optional().describe('Workspace manifest filename (required for doc/container)'),
+            itemId: z.string().describe('docId (8-char hex), containerId, or workspace filename'),
+            targetContainerId: z.string().optional().describe('Destination container (omit for root or same-parent reorder). Doc/container only.'),
+            afterId: z.string().optional().describe('Place after this item (omit for beginning)'),
+        },
+        handler: async ({ type, workspaceFile, itemId, targetContainerId, afterId }) => {
+            if (type === 'doc') {
+                if (!workspaceFile)
+                    return { content: [{ type: 'text', text: 'Error: workspaceFile is required for doc moves' }] };
+                const filename = resolveDocId(itemId);
+                const ws = getWorkspace(workspaceFile);
+                const existing = findDocNode(ws.root, filename);
+                if (existing) {
+                    moveDoc(workspaceFile, filename, targetContainerId ?? null, afterId ?? null);
+                }
+                else {
+                    const title = getDocTitle(filename);
+                    addDoc(workspaceFile, targetContainerId ?? null, filename, title, afterId ?? null);
+                }
+                broadcastWorkspacesChanged();
+                const action = existing ? 'Moved' : 'Added';
+                return { content: [{ type: 'text', text: `${action} "${filename}"${targetContainerId ? ` to container ${targetContainerId}` : ' to root'}` }] };
+            }
+            if (type === 'container') {
+                if (!workspaceFile)
+                    return { content: [{ type: 'text', text: 'Error: workspaceFile is required for container moves' }] };
+                if (targetContainerId !== undefined) {
+                    moveContainer(workspaceFile, itemId, targetContainerId, afterId ?? null);
+                }
+                else {
+                    moveContainer(workspaceFile, itemId, null, afterId ?? null);
+                }
+                broadcastWorkspacesChanged();
+                return { content: [{ type: 'text', text: `Moved container "${itemId}"${targetContainerId ? ` to container ${targetContainerId}` : ''}${afterId ? ` after ${afterId}` : ' to beginning'}` }] };
             }
-            else {
-                const title = getDocTitle(filename);
-                addDoc(workspaceFile, targetContainerId ?? null, filename, title, afterFile ?? null);
+            if (type === 'workspace') {
+                reorderWorkspaceAfter(itemId, afterId ?? null);
+                broadcastWorkspacesChanged();
+                return { content: [{ type: 'text', text: `Reordered workspace "${itemId}"${afterId ? ` after ${afterId}` : ' to beginning'}` }] };
             }
-            broadcastWorkspacesChanged();
-            const action = existing ? 'Moved' : 'Added';
-            return { content: [{ type: 'text', text: `${action} "${filename}"${targetContainerId ? ` to container ${targetContainerId}` : ' to root'}` }] };
+            return { content: [{ type: 'text', text: `Error: unknown type "${type}"` }] };
         },
     },
     {

package/dist/server/post-sync.js ADDED Viewed

@@ -0,0 +1,114 @@
+/**
+ * Post History Sync — pulls scheduler_history from platform,
+ * updates local doc frontmatter with lastPost metadata.
+ *
+ * The platform is the canonical record for posted items.
+ * Local frontmatter is a cached view for sidebar display.
+ */
+import { readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import matter from 'gray-matter';
+import { filenameByDocId } from './documents.js';
+import { getDataDir } from './helpers.js';
+import { isAuthenticated, platformFetch } from './connections.js';
+import { isExternalDoc } from './helpers.js';
+/**
+ * Sync posted history from platform → local doc frontmatter.
+ * For each history item with a doc_id:
+ *   - Find the local doc by docId
+ *   - Check if frontmatter already has a lastPost >= posted_at
+ *   - If not, write the appropriate context metadata
+ */
+export async function syncPostHistory() {
+    if (!isAuthenticated())
+        return { synced: 0, skipped: 0, errors: 0 };
+    let items;
+    try {
+        const res = await platformFetch('/scheduler/history');
+        if (!res.ok)
+            return { synced: 0, skipped: 0, errors: 0 };
+        const data = await res.json();
+        items = data.items || [];
+    }
+    catch {
+        return { synced: 0, skipped: 0, errors: 0 };
+    }
+    let synced = 0, skipped = 0, errors = 0;
+    for (const item of items) {
+        if (!item.doc_id || !item.result?.success || !item.posted_at) {
+            skipped++;
+            continue;
+        }
+        try {
+            const filename = filenameByDocId(item.doc_id);
+            if (!filename) {
+                skipped++;
+                continue;
+            }
+            const filePath = isExternalDoc(filename)
+                ? filename
+                : join(getDataDir(), filename);
+            const raw = readFileSync(filePath, 'utf-8');
+            const { data, content } = matter(raw);
+            // Determine the context key based on content_type/provider
+            const provider = item.provider || item.content_type;
+            let contextKey;
+            let lastPostField;
+            let urlField;
+            if (provider === 'x' || item.content_type === 'tweet' || item.content_type === 'thread') {
+                contextKey = 'tweetContext';
+                lastPostField = 'lastPost';
+                urlField = 'tweetUrl';
+            }
+            else if (provider === 'linkedin' || item.content_type === 'linkedin') {
+                contextKey = 'linkedinContext';
+                lastPostField = 'lastPost';
+                urlField = 'postUrl';
+            }
+            else if (item.content_type === 'blog' || provider === 'github') {
+                contextKey = 'blogContext';
+                lastPostField = 'lastPublish';
+                urlField = 'publishUrl';
+            }
+            else if (item.content_type === 'newsletter') {
+                // Newsletter uses its own sync path
+                skipped++;
+                continue;
+            }
+            else {
+                contextKey = 'tweetContext';
+                lastPostField = 'lastPost';
+                urlField = 'tweetUrl';
+            }
+            // Check if already synced (existing lastPost >= this posted_at)
+            const existingContext = data[contextKey] || {};
+            const existingPost = existingContext[lastPostField];
+            if (existingPost?.postedAt) {
+                const existingTime = new Date(existingPost.postedAt).getTime();
+                const newTime = new Date(item.posted_at).getTime();
+                if (existingTime >= newTime) {
+                    skipped++;
+                    continue;
+                }
+            }
+            // Write updated metadata
+            data[contextKey] = {
+                ...existingContext,
+                [lastPostField]: {
+                    postedAt: item.posted_at,
+                    ...(item.result.url ? { [urlField]: item.result.url } : {}),
+                },
+            };
+            const updated = matter.stringify(content, data);
+            writeFileSync(filePath, updated, 'utf-8');
+            synced++;
+        }
+        catch {
+            errors++;
+        }
+    }
+    if (synced > 0) {
+        console.log(`[PostSync] Synced ${synced} posted items to local docs`);
+    }
+    return { synced, skipped, errors };
+}

package/dist/server/scheduler-routes.js CHANGED Viewed

@@ -3,6 +3,7 @@
  */
 import { Router } from 'express';
 import { platformFetch, isAuthenticated } from './connections.js';
+import { syncPostHistory } from './post-sync.js';
 export function createSchedulerRouter() {
     const router = Router();
     function proxy(path, method = 'GET') {
@@ -115,8 +116,40 @@ export function createSchedulerRouter() {
     });
     // History
     router.get('/api/scheduler/history', proxy('/scheduler/history'));
+    // Sync post history from platform → local doc frontmatter
+    router.post('/api/scheduler/sync', async (_req, res) => {
+        try {
+            const result = await syncPostHistory();
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     // Available connections for scheduler
     router.get('/api/scheduler/connections', proxy('/scheduler/connections'));
+    // Upload media via connection (proxies to platform)
+    router.post('/api/connections/:id/upload-media', async (req, res) => {
+        try {
+            if (!isAuthenticated()) {
+                res.json({ error: 'Not authenticated' });
+                return;
+            }
+            const upstream = await platformFetch(`/connections/${req.params.id}/upload-media`, {
+                method: 'POST',
+                body: JSON.stringify(req.body),
+            });
+            const data = await upstream.json();
+            if (!upstream.ok) {
+                res.status(upstream.status).json(data);
+                return;
+            }
+            res.json(data);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     // --- Autoplugs ---
     // Goals
     router.get('/api/scheduler/autoplugs/goals', proxy('/scheduler/autoplugs/goals'));

package/dist/server/workspaces.js CHANGED Viewed

@@ -246,6 +246,41 @@ export function reorderContainer(wsFile, containerId, afterIdentifier) {
     writeWorkspace(wsFile, ws);
     return ws;
 }
+export function moveContainer(wsFile, containerId, targetContainerId, afterIdentifier) {
+    const ws = getWorkspace(wsFile);
+    moveNode(ws.root, containerId, targetContainerId, afterIdentifier);
+    writeWorkspace(wsFile, ws);
+    return ws;
+}
+export function reorderWorkspaceAfter(filename, afterFilename) {
+    ensureWorkspacesDir();
+    const order = readOrder();
+    // Ensure all current workspace files are in the order array
+    const files = readdirSync(getWorkspacesDir()).filter(f => f.endsWith('.json') && f !== '_order.json');
+    for (const f of files) {
+        if (!order.includes(f))
+            order.push(f);
+    }
+    // Remove target
+    const idx = order.indexOf(filename);
+    if (idx === -1)
+        throw new Error(`Workspace "${filename}" not found in order`);
+    order.splice(idx, 1);
+    // Insert
+    if (afterFilename === null) {
+        order.unshift(filename);
+    }
+    else {
+        const afterIdx = order.indexOf(afterFilename);
+        if (afterIdx === -1) {
+            order.push(filename);
+        }
+        else {
+            order.splice(afterIdx + 1, 0, filename);
+        }
+    }
+    writeOrder(order);
+}
 // ============================================================================
 // CONTEXT
 // ============================================================================

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "openwriter",
-  "version": "0.6.11",
+  "version": "0.7.0",
   "description": "The open-source writing surface for AI agents. Markdown-native editor with pending change review — your agent writes, you accept or reject.",
   "type": "module",
   "license": "MIT",