openwriter 0.5.4 → 0.6.0

package/dist/server/mcp.js

@@ -9,12 +9,13 @@ 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';
-import { listWorkspaces, getWorkspace, getDocTitle, getItemContext, addDoc, updateWorkspaceContext, createWorkspace, deleteWorkspace, addContainerToWorkspace, findOrCreateWorkspace, findOrCreateContainer, moveDoc, renameWorkspace, renameContainer } from './workspaces.js';
+import { listWorkspaces, getWorkspace, getDocTitle, getItemContext, addDoc, updateWorkspaceContext, createWorkspace, deleteWorkspace, addContainerToWorkspace, findOrCreateWorkspace, findOrCreateContainer, moveDoc, 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';
 import { toCompactFormat, compactNodes, parseMarkdownContent, mergeParagraphsToHardBreaks } from './compact.js';
 import matter from 'gray-matter';
@@ -23,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()) {
@@ -171,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) {
@@ -202,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);
@@ -211,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);
@@ -507,27 +538,11 @@ export const TOOL_REGISTRY = [
         description: 'Get progressive disclosure context for a document in a workspace: workspace-level context (characters, settings, rules) and tags. Use before writing to understand context.',
         schema: {
             workspaceFile: z.string().describe('Workspace manifest filename'),
-            docFile: z.string().describe('Document filename within the workspace'),
-        },
-        handler: async ({ workspaceFile, docFile }) => {
-            return { content: [{ type: 'text', text: JSON.stringify(getItemContext(workspaceFile, docFile), null, 2) }] };
+            docId: z.string().describe('Document docId (8-char hex from list_documents)'),
         },
-    },
-    {
-        name: 'add_doc',
-        description: 'Add a document to a workspace. Optionally place it inside a container.',
-        schema: {
-            workspaceFile: z.string().describe('Workspace manifest filename'),
-            docFile: z.string().describe('Document filename to add (e.g. "Chapter 1.md")'),
-            containerId: z.string().optional().describe('Container ID to add into (null = root level)'),
-            title: z.string().optional().describe('Display title for the doc'),
-        },
-        handler: async ({ workspaceFile, docFile, containerId, title }) => {
-            addDoc(workspaceFile, containerId ?? null, docFile, title || docFile.replace(/\.md$/, ''));
-            broadcastWorkspacesChanged();
-            return {
-                content: [{ type: 'text', text: `Added "${docFile}" to workspace${containerId ? ` in container ${containerId}` : ''}` }],
-            };
+        handler: async ({ workspaceFile, docId }) => {
+            const filename = resolveDocId(docId);
+            return { content: [{ type: 'text', text: JSON.stringify(getItemContext(workspaceFile, filename), null, 2) }] };
         },
     },
     {
@@ -561,45 +576,70 @@ export const TOOL_REGISTRY = [
             return { content: [{ type: 'text', text: `Created container "${name}" (id:${result.containerId})` }] };
         },
     },
+    {
+        name: 'delete_container',
+        description: 'Delete a container from a workspace. Any docs inside are removed from the workspace (files are NOT deleted from disk).',
+        schema: {
+            workspaceFile: z.string().describe('Workspace manifest filename'),
+            containerId: z.string().describe('Container ID to delete'),
+        },
+        handler: async ({ workspaceFile, containerId }) => {
+            removeContainer(workspaceFile, containerId);
+            broadcastWorkspacesChanged();
+            return { content: [{ type: 'text', text: `Deleted container ${containerId}` }] };
+        },
+    },
     {
         name: 'tag_doc',
         description: 'Add a tag to a document. Tags are stored in the document\'s frontmatter — they travel with the file. A doc can have multiple tags.',
         schema: {
-            docFile: z.string().describe('Document filename (e.g. "Chapter 1.md")'),
+            docId: z.string().describe('Document docId (8-char hex from list_documents)'),
             tag: z.string().describe('Tag name to add'),
         },
-        handler: async ({ docFile, tag }) => {
-            addDocTag(docFile, tag);
+        handler: async ({ docId, tag }) => {
+            const filename = resolveDocId(docId);
+            addDocTag(filename, tag);
             broadcastDocumentsChanged();
-            return { content: [{ type: 'text', text: `Tagged "${docFile}" with [${tag}]` }] };
+            return { content: [{ type: 'text', text: `Tagged "${filename}" with [${tag}]` }] };
         },
     },
     {
         name: 'untag_doc',
         description: 'Remove a tag from a document.',
         schema: {
-            docFile: z.string().describe('Document filename'),
+            docId: z.string().describe('Document docId (8-char hex from list_documents)'),
             tag: z.string().describe('Tag name to remove'),
         },
-        handler: async ({ docFile, tag }) => {
-            removeDocTag(docFile, tag);
+        handler: async ({ docId, tag }) => {
+            const filename = resolveDocId(docId);
+            removeDocTag(filename, tag);
             broadcastDocumentsChanged();
-            return { content: [{ type: 'text', text: `Removed tag [${tag}] from "${docFile}"` }] };
+            return { content: [{ type: 'text', text: `Removed tag [${tag}] from "${filename}"` }] };
         },
     },
     {
         name: 'move_doc',
-        description: 'Move a document to a different container within the same workspace, or to root level.',
+        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.',
         schema: {
             workspaceFile: z.string().describe('Workspace manifest filename'),
-            docFile: z.string().describe('Document filename to move'),
+            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, docFile, targetContainerId, afterFile }) => {
-            moveDoc(workspaceFile, docFile, targetContainerId ?? null, afterFile ?? null);
+        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);
+            }
+            else {
+                const title = getDocTitle(filename);
+                addDoc(workspaceFile, targetContainerId ?? null, filename, title, afterFile ?? null);
+            }
             broadcastWorkspacesChanged();
-            return { content: [{ type: 'text', text: `Moved "${docFile}"${targetContainerId ? ` to container ${targetContainerId}` : ' to root'}` }] };
+            const action = existing ? 'Moved' : 'Added';
+            return { content: [{ type: 'text', text: `${action} "${filename}"${targetContainerId ? ` to container ${targetContainerId}` : ' to root'}` }] };
         },
     },
     {
@@ -726,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`;
@@ -746,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) {
@@ -801,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`;
@@ -950,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--) {
@@ -972,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({
@@ -981,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;
+}