openwriter 0.2.1 → 0.3.0

package/dist/server/mcp-client.js

@@ -1,37 +1,38 @@
 /**
- * Client-mode MCP server: proxies all tool calls to the running pad server via HTTP.
- * Used when another terminal already owns port 5050.
- * No state, no express, no WebSocket — pure stdio-to-HTTP proxy.
+ * Client-mode MCP server: lightweight proxy to the running primary server.
+ * Zero local imports — fetches tool metadata via HTTP, proxies calls via HTTP.
+ * Used when another terminal already owns the port.
  */
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { TOOL_REGISTRY } from './mcp.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 export async function startMcpClientServer(port) {
-    const server = new McpServer({
-        name: 'open-writer-client',
-        version: '0.2.0',
-    });
     const baseUrl = `http://localhost:${port}`;
-    for (const tool of TOOL_REGISTRY) {
-        server.tool(tool.name, tool.description, tool.schema, async (args) => {
-            try {
-                const res = await fetch(`${baseUrl}/api/mcp-call`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ tool: tool.name, arguments: args }),
-                });
-                if (!res.ok) {
-                    const text = await res.text();
-                    return { content: [{ type: 'text', text: `Server error (${res.status}): ${text}` }] };
-                }
-                return await res.json();
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: `Connection error: ${err.message}` }] };
+    // Fetch tool metadata from the primary server
+    const res = await fetch(`${baseUrl}/api/mcp-tools`);
+    if (!res.ok)
+        throw new Error(`Failed to fetch tools from ${baseUrl}: ${res.status}`);
+    const { tools } = await res.json();
+    const server = new Server({ name: 'openwriter-client', version: '0.2.0' }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        try {
+            const callRes = await fetch(`${baseUrl}/api/mcp-call`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ tool: request.params.name, arguments: request.params.arguments }),
+            });
+            if (!callRes.ok) {
+                const text = await callRes.text();
+                return { content: [{ type: 'text', text: `Server error (${callRes.status}): ${text}` }] };
             }
-        });
-    }
-    console.error(`[MCP-Client] Proxying ${TOOL_REGISTRY.length} tools to ${baseUrl}`);
+            return await callRes.json();
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Connection error: ${err.message}` }] };
+        }
+    });
+    console.error(`[MCP-Client] Proxying ${tools.length} tools to ${baseUrl}`);
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }

package/dist/server/mcp.js

@@ -3,16 +3,21 @@
  * Uses compact wire format for token efficiency.
  * Exports TOOL_REGISTRY for HTTP proxy (multi-session support).
  */
+import { join } from 'path';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+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 { getDocument, getWordCount, getPendingChangeCount, getTitle, getStatus, getNodesByIds, getMetadata, setMetadata, applyChanges, applyTextEdits, updateDocument, save, markAllNodesAsPending, } from './state.js';
-import { listDocuments, switchDocument, createDocument, openFile, getActiveFilename } from './documents.js';
-import { broadcastDocumentSwitched, broadcastDocumentsChanged, broadcastWorkspacesChanged, broadcastTitleChanged, broadcastPendingDocsChanged } from './ws.js';
-import { listWorkspaces, getWorkspace, getDocTitle, getItemContext, addDoc, updateWorkspaceContext, createWorkspace, addContainerToWorkspace, tagDoc, untagDoc, moveDoc } from './workspaces.js';
+import { DATA_DIR, ensureDataDir } from './helpers.js';
+import { getDocument, getWordCount, getPendingChangeCount, getTitle, getStatus, getNodesByIds, getMetadata, setMetadata, applyChanges, applyTextEdits, updateDocument, save, markAllNodesAsPending, setAgentLock, } from './state.js';
+import { listDocuments, switchDocument, createDocument, deleteDocument, openFile, getActiveFilename } 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 } from './workspaces.js';
+import { addDocTag, removeDocTag, getDocTagsByFilename } from './state.js';
 import { importGoogleDoc } from './gdoc-import.js';
 import { toCompactFormat, compactNodes, parseMarkdownContent } from './compact.js';
-import { markdownToTiptap } from './markdown.js';
+import { getUpdateInfo } from './update-check.js';
 export const TOOL_REGISTRY = [
     {
         name: 'read_pad',
@@ -26,7 +31,7 @@ export const TOOL_REGISTRY = [
     },
     {
         name: 'write_to_pad',
-        description: 'Preferred tool for all document edits. Send 3-8 changes per call for responsive feel. Multiple rapid calls better than one monolithic call. Content can be a markdown string (preferred) or TipTap JSON. Markdown strings are auto-converted. Changes appear as pending decorations the user accepts or rejects.',
+        description: 'Preferred tool for all document edits. Send 3-8 changes per call for responsive feel. Multiple rapid calls better than one monolithic call. Content can be a markdown string (preferred) or TipTap JSON. Markdown strings are auto-converted. Changes appear as pending decorations the user accepts or rejects. Use afterNodeId: "end" to append to the document without knowing node IDs. Response includes lastNodeId for chaining subsequent inserts.',
         schema: {
             changes: z.array(z.object({
                 operation: z.enum(['rewrite', 'insert', 'delete']),
@@ -43,7 +48,7 @@ export const TOOL_REGISTRY = [
                 }
                 return resolved;
             });
-            const appliedCount = applyChanges(processed);
+            const { count: appliedCount, lastNodeId } = applyChanges(processed);
             broadcastPendingDocsChanged();
             return {
                 content: [{
@@ -51,6 +56,7 @@ export const TOOL_REGISTRY = [
                         text: JSON.stringify({
                             success: appliedCount > 0,
                             appliedCount,
+                            ...(lastNodeId ? { lastNodeId } : {}),
                             ...(appliedCount < processed.length ? { skipped: processed.length - appliedCount } : {}),
                         }),
                     }],
@@ -62,7 +68,10 @@ export const TOOL_REGISTRY = [
         description: 'Get the current status of the pad: word count, pending changes. Cheap call for polling.',
         schema: {},
         handler: async () => {
-            return { content: [{ type: 'text', text: JSON.stringify(getStatus()) }] };
+            const status = getStatus();
+            const latestVersion = getUpdateInfo();
+            const payload = latestVersion ? { ...status, updateAvailable: latestVersion } : status;
+            return { content: [{ type: 'text', text: JSON.stringify(payload) }] };
         },
     },
     {
@@ -96,6 +105,7 @@ export const TOOL_REGISTRY = [
             filename: z.string().describe('Filename of the document to switch to (e.g. "My Essay.md")'),
         },
         handler: async ({ filename }) => {
+            broadcastWritingFinished(); // Clear any in-progress creation spinner
             const result = switchDocument(filename);
             broadcastDocumentSwitched(result.document, result.title, result.filename);
             const compact = toCompactFormat(result.document, result.title, getWordCount(), getPendingChangeCount());
@@ -104,29 +114,117 @@ export const TOOL_REGISTRY = [
     },
     {
         name: 'create_document',
-        description: 'Create a new document and switch to it. Always provide a title — documents without one show as "Untitled". Saves the current document first. Accepts optional content as markdown string or TipTap JSON — if provided, the document is created with that content. Without content, creates an empty document. Use `path` to create the file at a specific location instead of ~/.openwriter/.',
+        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).',
         schema: {
             title: z.string().optional().describe('Title for the new document. Defaults to "Untitled".'),
-            content: z.any().optional().describe('Initial content: markdown string (preferred) or TipTap JSON doc object. If omitted, document starts empty.'),
             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 }) => {
+            // Resolve workspace/container up front so spinner renders in the right place
+            let wsTarget;
+            if (workspace) {
+                const ws = findOrCreateWorkspace(workspace);
+                let containerId = null;
+                if (container) {
+                    const c = findOrCreateContainer(ws.filename, container);
+                    containerId = c.containerId;
+                }
+                wsTarget = { wsFilename: ws.filename, containerId };
+                broadcastWorkspacesChanged(); // Browser sees container structure before spinner
+            }
+            if (!empty) {
+                broadcastWritingStarted(title || 'Untitled', wsTarget);
+                // Yield so the browser receives and renders the placeholder before heavy work
+                await new Promise((resolve) => setTimeout(resolve, 200));
+            }
+            try {
+                // Lock browser doc-updates: prevents race where browser sends a doc-update
+                // for the previous document but server has already switched active doc.
+                setAgentLock();
+                const result = createDocument(title, undefined, path);
+                // Auto-add to workspace if specified
+                let wsInfo = '';
+                if (wsTarget) {
+                    addDoc(wsTarget.wsFilename, wsTarget.containerId, result.filename, result.title);
+                    wsInfo = ` → workspace "${workspace}"${container ? ` / ${container}` : ''}`;
+                }
+                if (empty) {
+                    // Immediate switch — no spinner, no populate_document needed
+                    save();
+                    broadcastDocumentsChanged();
+                    broadcastWorkspacesChanged();
+                    broadcastDocumentSwitched(getDocument(), getTitle(), getActiveFilename());
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `Created "${result.title}" (${result.filename})${wsInfo} — ready.`,
+                            }],
+                    };
+                }
+                // Two-step flow: spinner persists until populate_document is called
+                setMetadata({ agentCreated: true });
+                save(); // Persist agentCreated flag to frontmatter
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Created "${result.title}" (${result.filename})${wsInfo} — empty. Call populate_document to add content.`,
+                        }],
+                };
+            }
+            catch (err) {
+                if (!empty)
+                    broadcastWritingFinished();
+                throw err;
+            }
+        },
+    },
+    {
+        name: 'populate_document',
+        description: 'Populate the active document with content. Use after create_document (without content) to complete the two-step creation flow. Content appears as pending decorations for user review. Clears the sidebar creation spinner and shows the document.',
+        schema: {
+            content: z.any().describe('Document content: markdown string (preferred) or TipTap JSON doc object.'),
         },
-        handler: async ({ title, content, path }) => {
-            const result = createDocument(title, content, path);
-            if (content) {
-                const doc = getDocument();
+        handler: async ({ content }) => {
+            try {
+                let doc;
+                if (typeof content === 'string') {
+                    doc = { type: 'doc', content: parseMarkdownContent(content) };
+                }
+                else if (content?.type === 'doc' && Array.isArray(content.content)) {
+                    doc = content;
+                }
+                else {
+                    broadcastWritingFinished();
+                    return {
+                        content: [{ type: 'text', text: 'Error: content must be a markdown string or TipTap JSON { type: "doc", content: [...] }' }],
+                    };
+                }
+                setAgentLock(); // Block browser doc-updates during population
                 markAllNodesAsPending(doc, 'insert');
                 updateDocument(doc);
                 save();
+                // Broadcast sidebar updates first (deferred from create_document) so the doc
+                // entry and spinner removal arrive in the same render cycle
+                broadcastDocumentsChanged();
+                broadcastWorkspacesChanged();
+                broadcastDocumentSwitched(doc, getTitle(), getActiveFilename());
+                broadcastPendingDocsChanged();
+                broadcastWritingFinished();
+                const wordCount = getWordCount();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Populated "${getTitle()}" — ${wordCount.toLocaleString()} words`,
+                        }],
+                };
+            }
+            catch (err) {
+                broadcastWritingFinished();
+                throw err;
             }
-            broadcastDocumentSwitched(result.document, result.title, result.filename);
-            broadcastPendingDocsChanged();
-            const wordCount = getWordCount();
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Created "${result.title}" (${result.filename})${wordCount > 0 ? ` — ${wordCount} words` : ''}`,
-                    }],
-            };
         },
     },
     {
@@ -143,43 +241,22 @@ export const TOOL_REGISTRY = [
         },
     },
     {
-        name: 'replace_document',
-        description: 'Only for importing external content into a new/blank document. Never use to edit a document you already wrote — use write_to_pad instead. Accepts markdown string (preferred) or TipTap JSON. Optionally updates the title.',
+        name: 'delete_document',
+        description: 'Delete a document file. Moves to OS trash (Recycle Bin / macOS Trash). If deleting the active document, automatically switches to the most recent remaining doc. Cannot delete the last document. IMPORTANT: Always confirm with the user before calling this tool.',
         schema: {
-            content: z.any().describe('New document content: markdown string (preferred) or TipTap JSON { type: "doc", content: [...] }'),
-            title: z.string().optional().describe('New title for the document. If omitted, title is unchanged (or extracted from markdown frontmatter).'),
-        },
-        handler: async ({ content, title }) => {
-            let doc;
-            let newTitle = title;
-            if (typeof content === 'string') {
-                const parsed = markdownToTiptap(content);
-                doc = parsed.document;
-                if (!newTitle && parsed.title !== 'Untitled')
-                    newTitle = parsed.title;
-            }
-            else if (content?.type === 'doc' && Array.isArray(content.content)) {
-                doc = content;
+            filename: z.string().describe('Filename of the document to delete (e.g. "My Essay.md")'),
+        },
+        handler: async ({ filename }) => {
+            const result = await deleteDocument(filename);
+            if (result.switched && result.newDoc) {
+                broadcastDocumentSwitched(result.newDoc.document, result.newDoc.title, result.newDoc.filename);
             }
-            else {
-                return {
-                    content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'content must be a markdown string or TipTap JSON { type: "doc", content: [...] }' }) }],
-                };
+            broadcastDocumentsChanged();
+            let text = `Deleted "${filename}" (moved to trash)`;
+            if (result.switched && result.newDoc) {
+                text += `. Switched to "${result.newDoc.filename}"`;
             }
-            const status = getWordCount() === 0 ? 'insert' : 'rewrite';
-            markAllNodesAsPending(doc, status);
-            updateDocument(doc);
-            if (newTitle)
-                setMetadata({ title: newTitle });
-            save();
-            broadcastDocumentSwitched(doc, newTitle || getTitle(), getActiveFilename());
-            broadcastPendingDocsChanged();
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Document replaced — ${getWordCount().toLocaleString()} words${newTitle ? `, title: "${newTitle}"` : ''}`,
-                    }],
-            };
+            return { content: [{ type: 'text', text }] };
         },
     },
     {
@@ -217,6 +294,7 @@ export const TOOL_REGISTRY = [
             for (const key of removed)
                 delete meta[key];
             save();
+            broadcastMetadataChanged(getMetadata());
             if (cleaned.title) {
                 broadcastTitleChanged(cleaned.title);
                 broadcastDocumentsChanged();
@@ -253,9 +331,26 @@ export const TOOL_REGISTRY = [
             return { content: [{ type: 'text', text: `Created workspace "${info.title}" (${info.filename})` }] };
         },
     },
+    {
+        name: 'delete_workspace',
+        description: 'Delete a workspace and all its document files. Files go to OS trash (Recycle Bin / macOS Trash). IMPORTANT: Always confirm with the user before calling this tool.',
+        schema: {
+            filename: z.string().describe('Workspace manifest filename (e.g. "my-novel-a1b2c3d4.json")'),
+        },
+        handler: async ({ filename }) => {
+            const result = await deleteWorkspace(filename);
+            broadcastWorkspacesChanged();
+            broadcastDocumentsChanged();
+            let text = `Deleted workspace "${filename}" and ${result.deletedFiles.length} files: ${result.deletedFiles.join(', ')}`;
+            if (result.skippedExternal.length > 0) {
+                text += `\nSkipped ${result.skippedExternal.length} external files (not owned by OpenWriter): ${result.skippedExternal.join(', ')}`;
+            }
+            return { content: [{ type: 'text', text }] };
+        },
+    },
     {
         name: 'get_workspace_structure',
-        description: 'Get the full structure of a workspace: tree of containers and docs, tags index, plus context (characters, settings, rules). Use to understand workspace organization before writing.',
+        description: 'Get the full structure of a workspace: tree of containers and docs, per-doc tags, plus context (characters, settings, rules). Use to understand workspace organization before writing.',
         schema: {
             filename: z.string().describe('Workspace manifest filename (e.g. "my-novel-a1b2c3d4.json")'),
         },
@@ -265,7 +360,9 @@ export const TOOL_REGISTRY = [
                 const lines = [];
                 for (const node of nodes) {
                     if (node.type === 'doc') {
-                        lines.push(`${indent}${getDocTitle(node.file)}  (${node.file})`);
+                        const tags = getDocTagsByFilename(node.file);
+                        const tagStr = tags.length > 0 ? `  [${tags.join(', ')}]` : '';
+                        lines.push(`${indent}${getDocTitle(node.file)}  (${node.file})${tagStr}`);
                     }
                     else {
                         lines.push(`${indent}[container] ${node.name}  (id:${node.id})`);
@@ -276,13 +373,6 @@ export const TOOL_REGISTRY = [
             }
             const treeLines = renderTree(ws.root, '  ');
             let text = `workspace: "${ws.title}"\nstructure:\n${treeLines.join('\n') || '  (empty)'}`;
-            const tagEntries = Object.entries(ws.tags);
-            if (tagEntries.length > 0) {
-                text += '\ntags:';
-                for (const [tag, files] of tagEntries) {
-                    text += `\n  ${tag}: ${files.join(', ')}`;
-                }
-            }
             if (ws.context && Object.keys(ws.context).length > 0) {
                 text += `\ncontext:\n${JSON.stringify(ws.context, null, 2)}`;
             }
@@ -350,29 +440,27 @@ export const TOOL_REGISTRY = [
     },
     {
         name: 'tag_doc',
-        description: 'Add a tag to a document in a workspace. Tags are cross-cutting — a doc can have multiple tags.',
+        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: {
-            workspaceFile: z.string().describe('Workspace manifest filename'),
-            docFile: z.string().describe('Document filename'),
+            docFile: z.string().describe('Document filename (e.g. "Chapter 1.md")'),
             tag: z.string().describe('Tag name to add'),
         },
-        handler: async ({ workspaceFile, docFile, tag }) => {
-            tagDoc(workspaceFile, docFile, tag);
-            broadcastWorkspacesChanged();
+        handler: async ({ docFile, tag }) => {
+            addDocTag(docFile, tag);
+            broadcastDocumentsChanged();
             return { content: [{ type: 'text', text: `Tagged "${docFile}" with [${tag}]` }] };
         },
     },
     {
         name: 'untag_doc',
-        description: 'Remove a tag from a document in a workspace.',
+        description: 'Remove a tag from a document.',
         schema: {
-            workspaceFile: z.string().describe('Workspace manifest filename'),
             docFile: z.string().describe('Document filename'),
             tag: z.string().describe('Tag name to remove'),
         },
-        handler: async ({ workspaceFile, docFile, tag }) => {
-            untagDoc(workspaceFile, docFile, tag);
-            broadcastWorkspacesChanged();
+        handler: async ({ docFile, tag }) => {
+            removeDocTag(docFile, tag);
+            broadcastDocumentsChanged();
             return { content: [{ type: 'text', text: `Removed tag [${tag}] from "${docFile}"` }] };
         },
     },
@@ -429,8 +517,61 @@ export const TOOL_REGISTRY = [
             return { content: [{ type: 'text', text }] };
         },
     },
+    {
+        name: 'generate_image',
+        description: 'Generate an image using Gemini Imagen 4. Saves to ~/.openwriter/_images/. Optionally sets it as the active article\'s cover image atomically. Requires GEMINI_API_KEY env var.',
+        schema: {
+            prompt: z.string().max(1000).describe('Image generation prompt (max 1000 chars)'),
+            aspect_ratio: z.string().optional().describe('Aspect ratio (default "16:9"). Use "5:2" for article covers.'),
+            set_cover: z.boolean().optional().describe('If true, atomically set the generated image as the article cover (articleContext.coverImage in metadata).'),
+        },
+        handler: async ({ prompt, aspect_ratio, set_cover }) => {
+            const apiKey = process.env.GEMINI_API_KEY;
+            if (!apiKey) {
+                return { content: [{ type: 'text', text: 'Error: GEMINI_API_KEY environment variable is not set.' }] };
+            }
+            const { GoogleGenAI } = await import('@google/genai');
+            const ai = new GoogleGenAI({ apiKey });
+            const response = await ai.models.generateImages({
+                model: 'imagen-4.0-generate-001',
+                prompt,
+                config: {
+                    numberOfImages: 1,
+                    aspectRatio: (aspect_ratio || '16:9'),
+                },
+            });
+            const image = response.generatedImages?.[0];
+            if (!image?.image?.imageBytes) {
+                return { content: [{ type: 'text', text: 'Error: Gemini returned no image data.' }] };
+            }
+            // Save to ~/.openwriter/_images/
+            ensureDataDir();
+            const imagesDir = join(DATA_DIR, '_images');
+            if (!existsSync(imagesDir))
+                mkdirSync(imagesDir, { recursive: true });
+            const filename = `${randomUUID().slice(0, 8)}.png`;
+            const filePath = join(imagesDir, filename);
+            writeFileSync(filePath, Buffer.from(image.image.imageBytes, 'base64'));
+            const src = `/_images/${filename}`;
+            // Optionally set as article cover
+            if (set_cover) {
+                const meta = getMetadata();
+                const articleContext = meta.articleContext || {};
+                articleContext.coverImage = src;
+                setMetadata({ articleContext });
+                save();
+                broadcastMetadataChanged(getMetadata());
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, src, ...(set_cover ? { coverSet: true } : {}) }),
+                    }],
+            };
+        },
+    },
 ];
-/** Register MCP tools from plugins. Call before startMcpServer(). */
+/** Register MCP tools from plugins. Tools added after startMcpServer() won't be visible to existing MCP sessions. */
 export function registerPluginTools(tools) {
     for (const tool of tools) {
         TOOL_REGISTRY.push({
@@ -444,9 +585,18 @@ export function registerPluginTools(tools) {
         });
     }
 }
+/** Remove MCP tools by name. Existing MCP stdio sessions won't see removal until reconnect. */
+export function removePluginTools(names) {
+    const nameSet = new Set(names);
+    for (let i = TOOL_REGISTRY.length - 1; i >= 0; i--) {
+        if (nameSet.has(TOOL_REGISTRY[i].name)) {
+            TOOL_REGISTRY.splice(i, 1);
+        }
+    }
+}
 export async function startMcpServer() {
     const server = new McpServer({
-        name: 'open-writer',
+        name: 'openwriter',
         version: '0.2.0',
     });
     for (const tool of TOOL_REGISTRY) {

package/dist/server/plugin-discovery.js

@@ -0,0 +1,64 @@
+/**
+ * Plugin discovery: scans the plugins/ directory for available plugins.
+ * Reads package.json metadata without importing or loading the plugin code.
+ */
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Scan the plugins/ directory at the monorepo root.
+ * Returns metadata from each plugin's package.json without importing code.
+ * Returns [] if plugins/ doesn't exist (e.g. npm install scenario).
+ */
+export function discoverPlugins() {
+    // At runtime: dist/server/ → ../../../.. → monorepo root → /plugins/
+    const pluginsDir = join(__dirname, '..', '..', '..', '..', 'plugins');
+    if (!existsSync(pluginsDir))
+        return [];
+    const results = [];
+    for (const entry of readdirSync(pluginsDir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const pkgPath = join(pluginsDir, entry.name, 'package.json');
+        if (!existsSync(pkgPath))
+            continue;
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+            if (!pkg.name)
+                continue;
+            results.push({
+                name: pkg.name,
+                dirName: entry.name,
+                version: pkg.version || '0.0.0',
+                description: pkg.description || '',
+            });
+        }
+        catch {
+            // Skip malformed package.json
+        }
+    }
+    return results;
+}
+/**
+ * Import a plugin by npm package name and extract its metadata.
+ * Returns the plugin's configSchema and full module export.
+ */
+export async function loadPluginModule(name) {
+    try {
+        const mod = await import(name);
+        const plugin = mod.default || mod.plugin || mod;
+        if (!plugin.name || !plugin.version)
+            return null;
+        return {
+            plugin,
+            configSchema: plugin.configSchema || {},
+        };
+    }
+    catch (err) {
+        console.error(`[PluginDiscovery] Failed to import "${name}":`, err.message);
+        return null;
+    }
+}