openwriter 0.5.5 → 0.6.1

package/dist/server/marks.js

@@ -5,17 +5,17 @@
 import { join } from 'path';
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, unlinkSync, renameSync } from 'fs';
 import { randomUUID } from 'crypto';
-import { DATA_DIR, ensureDataDir } from './helpers.js';
-const MARKS_DIR = join(DATA_DIR, '_marks');
+import { getDataDir, ensureDataDir } from './helpers.js';
+function getMarksDir() { return join(getDataDir(), '_marks'); }
 function ensureMarksDir() {
     ensureDataDir();
-    if (!existsSync(MARKS_DIR))
-        mkdirSync(MARKS_DIR, { recursive: true });
+    if (!existsSync(getMarksDir()))
+        mkdirSync(getMarksDir(), { recursive: true });
 }
 function markFilePath(filename) {
     // Sanitize: replace path separators to avoid nested paths
     const safe = filename.replace(/[/\\]/g, '_');
-    return join(MARKS_DIR, `${safe}.json`);
+    return join(getMarksDir(), `${safe}.json`);
 }
 function readMarkFile(filename) {
     const path = markFilePath(filename);
@@ -63,13 +63,13 @@ export function getMarks(filename) {
     ensureMarksDir();
     const result = {};
     try {
-        const files = readdirSync(MARKS_DIR);
+        const files = readdirSync(getMarksDir());
         for (const file of files) {
             if (!file.endsWith('.json'))
                 continue;
             const docFilename = file.replace(/\.json$/, '').replace(/_/g, ' ');
             // Read raw to avoid filename roundtrip issues
-            const path = join(MARKS_DIR, file);
+            const path = join(getMarksDir(), file);
             try {
                 const data = JSON.parse(readFileSync(path, 'utf-8'));
                 if (data.marks.length > 0)
@@ -90,7 +90,7 @@ export function getGlobalMarkSummary(excludeFilename) {
     let totalMarks = 0;
     let docCount = 0;
     try {
-        const files = readdirSync(MARKS_DIR);
+        const files = readdirSync(getMarksDir());
         for (const file of files) {
             if (!file.endsWith('.json'))
                 continue;
@@ -99,7 +99,7 @@ export function getGlobalMarkSummary(excludeFilename) {
                 if (file === `${safe}.json`)
                     continue;
             }
-            const path = join(MARKS_DIR, file);
+            const path = join(getMarksDir(), file);
             try {
                 const data = JSON.parse(readFileSync(path, 'utf-8'));
                 if (data.marks.length > 0) {
@@ -118,11 +118,11 @@ export function resolveMarks(ids) {
     const resolved = [];
     ensureMarksDir();
     try {
-        const files = readdirSync(MARKS_DIR);
+        const files = readdirSync(getMarksDir());
         for (const file of files) {
             if (!file.endsWith('.json'))
                 continue;
-            const filePath = join(MARKS_DIR, file);
+            const filePath = join(getMarksDir(), file);
             try {
                 const data = JSON.parse(readFileSync(filePath, 'utf-8'));
                 const before = data.marks.length;

package/dist/server/mcp.js

@@ -9,7 +9,7 @@ import { randomUUID } from 'crypto';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
-import { DATA_DIR, ensureDataDir, resolveDocPath } from './helpers.js';
+import { getDataDir, ensureDataDir, resolveDocPath } from './helpers.js';
 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';
@@ -24,6 +24,19 @@ import { listVersions, forceSnapshot, restoreVersion } from './versions.js';
 import { markdownToTiptap } from './markdown.js';
 import { getMarks, getMarkCount, getGlobalMarkSummary, resolveMarks } from './marks.js';
 import { broadcastMarksChanged } from './ws.js';
+/** Map a content type string to its frontmatter metadata object. */
+function resolveTypeMeta(type) {
+    switch (type) {
+        case 'tweet': return { tweetContext: { mode: 'tweet' } };
+        case 'reply': return { tweetContext: { mode: 'reply' } };
+        case 'quote': return { tweetContext: { mode: 'quote' } };
+        case 'article': return { articleContext: { active: true } };
+        case 'linkedin': return { linkedinContext: { active: true } };
+        case 'newsletter': return { newsletterContext: { active: true } };
+        case 'blog': return { blogContext: { active: true } };
+        default: return undefined;
+    }
+}
 /** Check if a document is in tweet compose mode (has tweetContext metadata). */
 function isTweetDoc(filename) {
     if (!filename || filename === getActiveFilename()) {
@@ -172,15 +185,24 @@ export const TOOL_REGISTRY = [
     },
     {
         name: 'create_document',
-        description: 'Create a new empty document and switch to it. Always provide a title. Saves the current document first. By default shows a sidebar spinner that persists until populate_document is called — set empty=true to skip the spinner and switch immediately (use for template docs like tweets/articles that don\'t need agent content). If workspace is provided, the doc is automatically added to it (workspace is created if it doesn\'t exist). If container is also provided, the doc is placed inside that container (created if it doesn\'t exist).',
+        description: 'Create a new empty document and switch to it. Always provide a title. Saves the current document first. By default shows a sidebar spinner that persists until populate_document is called — set empty=true to skip the spinner and switch immediately (use for template docs like tweets/articles that don\'t need agent content). If workspace is provided, the doc is automatically added to it (workspace is created if it doesn\'t exist). If container is also provided, the doc is placed inside that container (created if it doesn\'t exist). Use content_type to create typed documents (tweet, article, linkedin, etc.) with the correct metadata pre-set.',
         schema: {
             title: z.string().optional().describe('Title for the new document. Defaults to "Untitled".'),
             path: z.string().optional().describe('Absolute file path to create the document at (e.g. "C:/projects/doc.md"). If omitted, creates in ~/.openwriter/.'),
             workspace: z.string().optional().describe('Workspace title to add this doc to. Creates the workspace if it doesn\'t exist.'),
             container: z.string().optional().describe('Container name within the workspace (e.g. "Chapters", "Notes", "References"). Creates the container if it doesn\'t exist. Requires workspace.'),
             empty: z.boolean().optional().describe('If true, skip the writing spinner and switch to the doc immediately. No need to call populate_document. Use for template docs (tweets, articles) that start empty.'),
-        },
-        handler: async ({ title, path, workspace, container, empty }) => {
+            content_type: z.string().optional().describe('Content type: tweet, reply, quote, article, linkedin, newsletter, or blog. Sets metadata so the doc is recognized as that type. For reply/quote, use set_metadata after creation to set the target tweet URL.'),
+        },
+        handler: async ({ title, path, workspace, container, empty, content_type }) => {
+            // Default title from content_type if not provided
+            if (!title && content_type) {
+                const typeDefaults = {
+                    tweet: 'Tweet', reply: 'Reply', quote: 'Quote Tweet', article: 'Article',
+                    linkedin: 'LinkedIn Post', newsletter: 'Newsletter', blog: 'Blog Post',
+                };
+                title = typeDefaults[content_type];
+            }
             // Resolve workspace/container up front so spinner renders in the right place
             let wsTarget;
             if (workspace) {
@@ -203,6 +225,13 @@ export const TOOL_REGISTRY = [
                     // Immediate switch — no spinner, no populate_document needed
                     setAgentLock();
                     const result = createDocument(title, undefined, path);
+                    // Apply type-specific metadata
+                    if (content_type) {
+                        const typeMeta = resolveTypeMeta(content_type);
+                        if (typeMeta) {
+                            setMetadata(typeMeta);
+                        }
+                    }
                     let wsInfo = '';
                     if (wsTarget) {
                         addDoc(wsTarget.wsFilename, wsTarget.containerId, result.filename, result.title);
@@ -212,17 +241,18 @@ export const TOOL_REGISTRY = [
                     save();
                     broadcastDocumentsChanged();
                     broadcastWorkspacesChanged();
-                    broadcastDocumentSwitched(getDocument(), getTitle(), getActiveFilename());
+                    broadcastDocumentSwitched(getDocument(), getTitle(), getActiveFilename(), getMetadata());
                     return {
                         content: [{
                                 type: 'text',
-                                text: `Created "${result.title}" [${newDocId}]${wsInfo} — ready.`,
+                                text: `Created "${result.title}" [${newDocId}]${wsInfo}${content_type ? ` (${content_type})` : ''} — ready.`,
                             }],
                     };
                 }
                 // Two-step flow: create file on disk WITHOUT switching the user's view.
                 // The spinner persists in the sidebar until populate_document is called.
-                const result = createDocumentFile(title, path);
+                const typeMeta = content_type ? resolveTypeMeta(content_type) : undefined;
+                const result = createDocumentFile(title, path, typeMeta);
                 let wsInfo = '';
                 if (wsTarget) {
                     addDoc(wsTarget.wsFilename, wsTarget.containerId, result.filename, result.title);
@@ -736,7 +766,7 @@ export const TOOL_REGISTRY = [
             }
             // Save to ~/.openwriter/_images/
             ensureDataDir();
-            const imagesDir = join(DATA_DIR, '_images');
+            const imagesDir = join(getDataDir(), '_images');
             if (!existsSync(imagesDir))
                 mkdirSync(imagesDir, { recursive: true });
             const filename = `${randomUUID().slice(0, 8)}.png`;
@@ -756,8 +786,10 @@ export const TOOL_REGISTRY = [
                             }],
                     };
                 }
-                // Use pre-await metadata snapshot to build the update (not live state)
-                const articleContext = preAwaitMeta.articleContext || {};
+                // Use LIVE metadata for coverImages (not stale pre-await snapshot)
+                // so concurrent generate_image calls don't overwrite each other's results
+                const liveMeta = getMetadata();
+                const articleContext = liveMeta.articleContext || {};
                 let existing = Array.isArray(articleContext.coverImages) ? [...articleContext.coverImages] : [];
                 // Seed with current coverImage if array is empty (first carousel entry)
                 if (existing.length === 0 && articleContext.coverImage) {
@@ -811,7 +843,7 @@ export const TOOL_REGISTRY = [
             }
             // Save to ~/.openwriter/_images/
             ensureDataDir();
-            const imagesDir = join(DATA_DIR, '_images');
+            const imagesDir = join(getDataDir(), '_images');
             if (!existsSync(imagesDir))
                 mkdirSync(imagesDir, { recursive: true });
             const imgFilename = `${randomUUID().slice(0, 8)}.png`;
@@ -960,21 +992,59 @@ export const TOOL_REGISTRY = [
         },
     },
 ];
-/** Register MCP tools from plugins. Tools added after startMcpServer() won't be visible to existing MCP sessions. */
+/** Live MCP server instance — used to register plugin tools dynamically. */
+let mcpServerInstance = null;
+/** Convert a JSON Schema properties object to a Zod shape for MCP tool registration. */
+function jsonSchemaToZodShape(inputSchema) {
+    const properties = (inputSchema.properties || {});
+    const required = new Set((inputSchema.required || []));
+    const shape = {};
+    for (const [key, prop] of Object.entries(properties)) {
+        let field;
+        switch (prop.type) {
+            case 'number':
+                field = z.number();
+                break;
+            case 'boolean':
+                field = z.boolean();
+                break;
+            default:
+                field = z.string();
+                break;
+        }
+        if (prop.description)
+            field = field.describe(prop.description);
+        if (!required.has(key))
+            field = field.optional();
+        shape[key] = field;
+    }
+    return shape;
+}
+/** Register MCP tools from plugins. Dynamically adds to the live MCP session. */
 export function registerPluginTools(tools) {
     for (const tool of tools) {
-        TOOL_REGISTRY.push({
+        const zodShape = jsonSchemaToZodShape(tool.inputSchema);
+        const toolDef = {
             name: tool.name,
             description: tool.description,
-            schema: {},
+            schema: zodShape,
             handler: async (args) => {
                 const result = await tool.handler(args);
                 return { content: [{ type: 'text', text: JSON.stringify(result) }] };
             },
-        });
+        };
+        TOOL_REGISTRY.push(toolDef);
+        // Register on live MCP server so existing sessions see it immediately
+        if (mcpServerInstance) {
+            mcpServerInstance.tool(tool.name, tool.description, zodShape, toolDef.handler);
+        }
+    }
+    // Notify connected clients that the tool list changed
+    if (mcpServerInstance) {
+        mcpServerInstance.server.sendToolListChanged().catch(() => { });
     }
 }
-/** Remove MCP tools by name. Existing MCP stdio sessions won't see removal until reconnect. */
+/** Remove MCP tools by name. Notifies connected clients of the change. */
 export function removePluginTools(names) {
     const nameSet = new Set(names);
     for (let i = TOOL_REGISTRY.length - 1; i >= 0; i--) {
@@ -982,6 +1052,9 @@ export function removePluginTools(names) {
             TOOL_REGISTRY.splice(i, 1);
         }
     }
+    if (mcpServerInstance) {
+        mcpServerInstance.server.sendToolListChanged().catch(() => { });
+    }
 }
 export async function startMcpServer() {
     const server = new McpServer({
@@ -991,6 +1064,7 @@ export async function startMcpServer() {
     for (const tool of TOOL_REGISTRY) {
         server.tool(tool.name, tool.description, tool.schema, tool.handler);
     }
+    mcpServerInstance = server;
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }

package/dist/server/plugin-manager.js

@@ -5,7 +5,7 @@
 import { Router as createRouter } from 'express';
 import { discoverPlugins, loadPluginModule } from './plugin-discovery.js';
 import { registerPluginTools, removePluginTools } from './mcp.js';
-import { readConfig, saveConfig } from './helpers.js';
+import { readConfig, saveConfig, getDataDir } from './helpers.js';
 import { broadcastPluginsChanged } from './ws.js';
 export class PluginManager {
     app;
@@ -55,7 +55,7 @@ export class PluginManager {
         // Register routes via togglable middleware
         if (plugin.registerRoutes) {
             const router = createRouter();
-            await plugin.registerRoutes({ app: router, config: resolvedConfig });
+            await plugin.registerRoutes({ app: router, config: resolvedConfig, dataDir: getDataDir() });
             managed.router = router;
             // Wrap in middleware that skips when disabled
             managed.middleware = (req, res, next) => {

package/dist/server/scheduler-routes.js

@@ -0,0 +1,121 @@
+/**
+ * Scheduler routes — proxy all requests to the platform API.
+ */
+import { Router } from 'express';
+import { platformFetch, isAuthenticated } from './connections.js';
+export function createSchedulerRouter() {
+    const router = Router();
+    function proxy(path, method = 'GET') {
+        return async (req, res) => {
+            try {
+                if (!isAuthenticated()) {
+                    res.json({ error: 'Not authenticated' });
+                    return;
+                }
+                const options = { method };
+                if (method !== 'GET' && method !== 'DELETE') {
+                    options.body = JSON.stringify(req.body);
+                }
+                const upstream = await platformFetch(path, options);
+                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 });
+            }
+        };
+    }
+    // Slots
+    router.get('/api/scheduler/slots', proxy('/scheduler/slots'));
+    router.post('/api/scheduler/slots', proxy('/scheduler/slots', 'POST'));
+    router.patch('/api/scheduler/slots/:id', async (req, res) => {
+        try {
+            if (!isAuthenticated()) {
+                res.json({ error: 'Not authenticated' });
+                return;
+            }
+            const upstream = await platformFetch(`/scheduler/slots/${req.params.id}`, {
+                method: 'PATCH',
+                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 });
+        }
+    });
+    router.delete('/api/scheduler/slots/:id', async (req, res) => {
+        try {
+            if (!isAuthenticated()) {
+                res.json({ error: 'Not authenticated' });
+                return;
+            }
+            const upstream = await platformFetch(`/scheduler/slots/${req.params.id}`, { method: 'DELETE' });
+            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 });
+        }
+    });
+    // Queue
+    router.get('/api/scheduler/queue', proxy('/scheduler/queue'));
+    router.post('/api/scheduler/queue', proxy('/scheduler/queue', 'POST'));
+    router.patch('/api/scheduler/queue/:id', async (req, res) => {
+        try {
+            if (!isAuthenticated()) {
+                res.json({ error: 'Not authenticated' });
+                return;
+            }
+            const upstream = await platformFetch(`/scheduler/queue/${req.params.id}`, {
+                method: 'PATCH',
+                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 });
+        }
+    });
+    router.delete('/api/scheduler/queue/:id', async (req, res) => {
+        try {
+            if (!isAuthenticated()) {
+                res.json({ error: 'Not authenticated' });
+                return;
+            }
+            const upstream = await platformFetch(`/scheduler/queue/${req.params.id}`, { method: 'DELETE' });
+            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 });
+        }
+    });
+    // History
+    router.get('/api/scheduler/history', proxy('/scheduler/history'));
+    // Available connections for scheduler
+    router.get('/api/scheduler/connections', proxy('/scheduler/connections'));
+    return router;
+}