openwriter 0.2.2 → 0.3.0

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 { 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, broadcastPendingDocsChanged, broadcastWritingStarted, broadcastWritingFinished } from './ws.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 { getUpdateInfo } from './update-check.js';
 export const TOOL_REGISTRY = [
     {
         name: 'read_pad',
@@ -63,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) }] };
         },
     },
     {
@@ -106,14 +114,15 @@ 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. Shows a sidebar spinner that persists until populate_document is called — always call populate_document next to add 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).',
         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 }) => {
+        handler: async ({ title, path, workspace, container, empty }) => {
             // Resolve workspace/container up front so spinner renders in the right place
             let wsTarget;
             if (workspace) {
@@ -126,24 +135,38 @@ export const TOOL_REGISTRY = [
                 wsTarget = { wsFilename: ws.filename, containerId };
                 broadcastWorkspacesChanged(); // Browser sees container structure before spinner
             }
-            broadcastWritingStarted(title || 'Untitled', wsTarget);
-            // Yield so the browser receives and renders the placeholder before heavy work
-            await new Promise((resolve) => setTimeout(resolve, 200));
+            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);
-                setMetadata({ agentCreated: true });
-                save(); // Persist agentCreated flag to frontmatter
-                // Auto-add to workspace if specified (defer sidebar broadcasts to populate_document
-                // so the real doc entry doesn't appear alongside the spinner placeholder)
+                // Auto-add to workspace if specified
                 let wsInfo = '';
                 if (wsTarget) {
                     addDoc(wsTarget.wsFilename, wsTarget.containerId, result.filename, result.title);
                     wsInfo = ` → workspace "${workspace}"${container ? ` / ${container}` : ''}`;
                 }
-                // Spinner persists until populate_document is called
+                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',
@@ -152,7 +175,8 @@ export const TOOL_REGISTRY = [
                 };
             }
             catch (err) {
-                broadcastWritingFinished();
+                if (!empty)
+                    broadcastWritingFinished();
                 throw err;
             }
         },
@@ -270,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();
@@ -492,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({
@@ -518,7 +596,7 @@ export function removePluginTools(names) {
 }
 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/state.js

@@ -10,6 +10,7 @@ import { tiptapToMarkdown, markdownToTiptap } from './markdown.js';
 import { applyTextEditsToNode } from './text-edit.js';
 import { DATA_DIR, TEMP_PREFIX, ensureDataDir, filePathForTitle, tempFilePath, generateNodeId, LEAF_BLOCK_TYPES, resolveDocPath, isExternalDoc } from './helpers.js';
 import { snapshotIfNeeded, ensureDocId } from './versions.js';
+import trash from 'trash';
 const DEFAULT_DOC = {
     type: 'doc',
     content: [{ type: 'paragraph', content: [] }],
@@ -143,6 +144,22 @@ export function setMetadata(updates) {
     state.metadata = { ...state.metadata, ...updates };
     if (updates.title)
         state.title = updates.title;
+    // Auto-tag: tweetContext / articleContext ↔ "x" tag
+    for (const key of ['tweetContext', 'articleContext']) {
+        if (key in updates) {
+            const filename = state.filePath
+                ? (isExternalDoc(state.filePath) ? state.filePath : state.filePath.split(/[/\\]/).pop() || '')
+                : '';
+            if (filename) {
+                if (updates[key]) {
+                    addDocTag(filename, 'x');
+                }
+                else {
+                    removeDocTag(filename, 'x');
+                }
+            }
+        }
+    }
 }
 export function getStatus() {
     return {
@@ -621,6 +638,8 @@ export function load() {
     migrateSwJsonFiles();
     // Clean up empty temp files from previous sessions
     cleanupEmptyTempFiles();
+    // Trash docs marked as ephemeral from previous sessions
+    cleanupEphemeralDocs();
     // Find most recently modified .md file
     const files = readdirSync(DATA_DIR)
         .filter((f) => f.endsWith('.md'))
@@ -630,33 +649,38 @@ export function load() {
         return { name: f, path: fullPath, mtime: stat.mtimeMs };
     })
         .sort((a, b) => b.mtime - a.mtime);
-    if (files.length === 0) {
-        // No existing docs — start fresh with temp file
-        state.filePath = tempFilePath();
-        state.isTemp = true;
-        return;
-    }
-    // Open the most recent file
-    const latest = files[0];
-    try {
-        const raw = readFileSync(latest.path, 'utf-8');
-        const parsed = markdownToTiptap(raw);
-        state.document = parsed.document;
-        state.title = parsed.title;
-        state.metadata = parsed.metadata;
-        state.lastModified = new Date(statSync(latest.path).mtimeMs);
-        state.filePath = latest.path;
-        state.isTemp = latest.name.startsWith(TEMP_PREFIX);
-        // Lazy docId migration: assign if missing, save to persist
-        const hadDocId = !!state.metadata.docId;
-        state.docId = ensureDocId(state.metadata);
-        if (!hadDocId) {
-            const md = tiptapToMarkdown(state.document, state.title, state.metadata);
-            writeFileSync(state.filePath, md, 'utf-8');
+    // Walk sorted files until we find a real document with content.
+    // Skip empty temp files so we don't open a blank scratch pad when real docs exist.
+    for (const file of files) {
+        try {
+            const raw = readFileSync(file.path, 'utf-8');
+            const parsed = markdownToTiptap(raw);
+            const isTemp = file.name.startsWith(TEMP_PREFIX);
+            // Skip empty temp files — prefer a real document
+            if (isTemp && isDocEmpty(parsed.document))
+                continue;
+            state.document = parsed.document;
+            state.title = parsed.title;
+            state.metadata = parsed.metadata;
+            state.lastModified = new Date(statSync(file.path).mtimeMs);
+            state.filePath = file.path;
+            state.isTemp = isTemp;
+            // Lazy docId migration: assign if missing, save to persist
+            const hadDocId = !!state.metadata.docId;
+            state.docId = ensureDocId(state.metadata);
+            if (!hadDocId) {
+                const md = tiptapToMarkdown(state.document, state.title, state.metadata);
+                writeFileSync(state.filePath, md, 'utf-8');
+            }
+            break;
+        }
+        catch {
+            // Corrupt file — try next one
+            continue;
         }
     }
-    catch {
-        // Corrupt file — start fresh
+    // If nothing loaded (all files were empty temps or corrupt), start fresh
+    if (!state.filePath) {
         state.filePath = tempFilePath();
         state.isTemp = true;
     }
@@ -766,6 +790,26 @@ function cleanupEmptyTempFiles() {
     }
     catch { /* ignore errors during cleanup */ }
 }
+/** Delete docs marked as ephemeral from previous sessions */
+function cleanupEphemeralDocs() {
+    try {
+        const wsRefs = getWorkspaceReferencedFiles();
+        const files = readdirSync(DATA_DIR).filter(f => f.endsWith('.md'));
+        for (const f of files) {
+            if (wsRefs.has(f))
+                continue; // protect workspace-referenced docs
+            try {
+                const raw = readFileSync(join(DATA_DIR, f), 'utf-8');
+                const { data } = matter(raw);
+                if (data.ephemeral) {
+                    trash(join(DATA_DIR, f)).catch(() => { }); // move to OS trash, fire-and-forget
+                }
+            }
+            catch { /* skip unreadable */ }
+        }
+    }
+    catch { /* ignore */ }
+}
 // ============================================================================
 // DOCUMENT-LEVEL TAG OPERATIONS
 // ============================================================================

package/dist/server/tweet-routes.js

@@ -0,0 +1,98 @@
+/**
+ * Tweet embed proxy: fetches tweet data from fxtwitter API.
+ * GET /api/tweet-embed?url=... → normalized TweetEmbedData JSON.
+ */
+import { Router } from 'express';
+// In-memory cache: URL → { data, expires }
+const cache = new Map();
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+function parseTweetUrl(url) {
+    try {
+        const parsed = new URL(url);
+        if (!['twitter.com', 'x.com', 'www.twitter.com', 'www.x.com'].includes(parsed.hostname)) {
+            return null;
+        }
+        // Path: /{username}/status/{id}
+        const match = parsed.pathname.match(/^\/([^/]+)\/status\/(\d+)/);
+        if (!match)
+            return null;
+        return { username: match[1], statusId: match[2] };
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeTweet(tweet) {
+    const data = {
+        author: {
+            name: tweet.author?.name || '',
+            username: tweet.author?.screen_name || '',
+            avatarUrl: tweet.author?.avatar_url || '',
+        },
+        text: tweet.text || '',
+        createdAt: tweet.created_at || '',
+        metrics: {
+            likes: tweet.likes ?? 0,
+            retweets: tweet.retweets ?? 0,
+            replies: tweet.replies ?? 0,
+            views: tweet.views ?? 0,
+        },
+    };
+    if (tweet.media?.all?.length) {
+        data.media = tweet.media.all.map((m) => ({
+            type: m.type || 'photo',
+            url: m.url || m.thumbnail_url || '',
+        }));
+    }
+    if (tweet.quote) {
+        data.quoteTweet = normalizeTweet(tweet.quote);
+    }
+    return data;
+}
+export function createTweetRouter() {
+    const router = Router();
+    router.get('/api/tweet-embed', async (req, res) => {
+        const url = req.query.url;
+        if (!url) {
+            res.status(400).json({ error: 'url query parameter is required' });
+            return;
+        }
+        const parsed = parseTweetUrl(url);
+        if (!parsed) {
+            res.status(400).json({ error: 'Invalid tweet URL. Supports x.com and twitter.com URLs.' });
+            return;
+        }
+        // Check cache
+        const cacheKey = `${parsed.username}/${parsed.statusId}`;
+        const cached = cache.get(cacheKey);
+        if (cached && cached.expires > Date.now()) {
+            res.json(cached.data);
+            return;
+        }
+        try {
+            const apiUrl = `https://api.fxtwitter.com/${parsed.username}/status/${parsed.statusId}`;
+            const response = await fetch(apiUrl);
+            if (!response.ok) {
+                if (response.status === 404) {
+                    res.status(404).json({ error: 'Tweet not found' });
+                    return;
+                }
+                res.status(502).json({ error: `fxtwitter API returned ${response.status}` });
+                return;
+            }
+            const json = await response.json();
+            if (!json.tweet) {
+                res.status(404).json({ error: 'Tweet not found in API response' });
+                return;
+            }
+            const data = normalizeTweet(json.tweet);
+            // Cache it
+            cache.set(cacheKey, { data, expires: Date.now() + CACHE_TTL_MS });
+            res.json(data);
+        }
+        catch (err) {
+            res.status(502).json({ error: `Failed to fetch tweet: ${err.message}` });
+        }
+    });
+    return router;
+}

package/dist/server/update-check.js

@@ -0,0 +1,96 @@
+/**
+ * Built-in update check — zero dependencies.
+ * Uses Node's built-in fetch + existing config system.
+ * Fire-and-forget: never blocks startup, never throws to caller.
+ */
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { readConfig, saveConfig } from './helpers.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const FETCH_TIMEOUT_MS = 5000;
+let cachedLatestVersion = null;
+/** Compare two semver strings numerically. Returns -1, 0, or 1. */
+export function compareVersions(a, b) {
+    const partsA = a.split('.').map((s) => parseInt(s, 10));
+    const partsB = b.split('.').map((s) => parseInt(s, 10));
+    const len = Math.max(partsA.length, partsB.length);
+    for (let i = 0; i < len; i++) {
+        const numA = partsA[i] || 0;
+        const numB = partsB[i] || 0;
+        if (numA < numB)
+            return -1;
+        if (numA > numB)
+            return 1;
+    }
+    return 0;
+}
+/** Read current package version from package.json on disk. */
+function getCurrentVersion() {
+    try {
+        const pkgPath = join(__dirname, '../../package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        return pkg.version || '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/**
+ * Check npm registry for a newer version. Fire-and-forget.
+ * - Respects NO_UPDATE_NOTIFIER env var
+ * - Caches result for 24h in config
+ * - Logs to stderr if update available
+ */
+export async function checkForUpdate() {
+    if (process.env.NO_UPDATE_NOTIFIER)
+        return;
+    const config = readConfig();
+    const now = Date.now();
+    const currentVersion = getCurrentVersion();
+    // Use cached result if checked within 24h
+    if (config.lastUpdateCheck && config.latestVersion) {
+        const lastCheck = new Date(config.lastUpdateCheck).getTime();
+        if (now - lastCheck < CHECK_INTERVAL_MS) {
+            if (compareVersions(currentVersion, config.latestVersion) < 0) {
+                cachedLatestVersion = config.latestVersion;
+                console.error(`[OpenWriter] Update available: ${currentVersion} → ${config.latestVersion} — run: npm update -g openwriter`);
+            }
+            return;
+        }
+    }
+    // Fetch latest version from npm registry
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+        const res = await fetch('https://registry.npmjs.org/openwriter/latest', {
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        if (!res.ok)
+            return;
+        const data = (await res.json());
+        const latestVersion = data.version;
+        if (!latestVersion)
+            return;
+        // Save to config for 24h cache
+        saveConfig({
+            lastUpdateCheck: new Date().toISOString(),
+            latestVersion,
+        });
+        if (compareVersions(currentVersion, latestVersion) < 0) {
+            cachedLatestVersion = latestVersion;
+            console.error(`[OpenWriter] Update available: ${currentVersion} → ${latestVersion} — run: npm update -g openwriter`);
+        }
+    }
+    catch {
+        // Network error, timeout, abort — silently ignore
+        clearTimeout(timeout);
+    }
+}
+/** Sync getter: returns latest version string if update available, null otherwise. */
+export function getUpdateInfo() {
+    return cachedLatestVersion;
+}

package/dist/server/ws.js

@@ -49,6 +49,7 @@ export function setupWebSocket(server) {
             title: getTitle(),
             filename,
             docId: getDocId(),
+            metadata: getMetadata(),
         }));
         // Send pending docs info on connect
         ws.send(JSON.stringify({
@@ -85,6 +86,7 @@ export function setupWebSocket(server) {
                         title: getTitle(),
                         filename,
                         docId: getDocId(),
+                        metadata: getMetadata(),
                     }));
                 }
                 if (msg.type === 'title-update' && msg.title) {
@@ -112,6 +114,33 @@ export function setupWebSocket(server) {
                         console.error('[WS] Create document failed:', err.message);
                     }
                 }
+                if (msg.type === 'create-template' && msg.template) {
+                    try {
+                        const tmpl = msg.template;
+                        const url = msg.url;
+                        // Create with no title → temp file path (avoids naming conflicts)
+                        const result = createDocument();
+                        // Set template-appropriate metadata
+                        if (tmpl === 'tweet') {
+                            setMetadata({ tweetContext: { mode: 'tweet' }, title: 'Tweet' });
+                        }
+                        else if (tmpl === 'reply') {
+                            setMetadata({ tweetContext: { url, mode: 'reply' }, title: 'Reply' });
+                        }
+                        else if (tmpl === 'quote') {
+                            setMetadata({ tweetContext: { url, mode: 'quote' }, title: 'Quote Tweet' });
+                        }
+                        else if (tmpl === 'article') {
+                            setMetadata({ articleContext: { active: true }, title: 'Article' });
+                        }
+                        save();
+                        broadcastDocumentSwitched(result.document, getTitle(), result.filename, getMetadata());
+                        broadcastDocumentsChanged();
+                    }
+                    catch (err) {
+                        console.error('[WS] Create template failed:', err.message);
+                    }
+                }
                 if (msg.type === 'pending-resolved' && msg.filename) {
                     const action = msg.action; // 'accept' or 'reject'
                     const resolvedFilename = msg.filename;
@@ -168,14 +197,21 @@ export function setupWebSocket(server) {
         });
     });
 }
-export function broadcastDocumentSwitched(document, title, filename) {
-    const msg = JSON.stringify({ type: 'document-switched', document, title, filename, docId: getDocId() });
+export function broadcastDocumentSwitched(document, title, filename, metadata) {
+    const msg = JSON.stringify({ type: 'document-switched', document, title, filename, docId: getDocId(), metadata: metadata ?? getMetadata() });
     for (const ws of clients) {
         if (ws.readyState === WebSocket.OPEN) {
             ws.send(msg);
         }
     }
 }
+export function broadcastMetadataChanged(metadata) {
+    const msg = JSON.stringify({ type: 'metadata-changed', metadata });
+    for (const ws of clients) {
+        if (ws.readyState === WebSocket.OPEN)
+            ws.send(msg);
+    }
+}
 export function broadcastDocumentsChanged() {
     const msg = JSON.stringify({ type: 'documents-changed' });
     for (const ws of clients) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openwriter",
-  "version": "0.2.2",
+  "version": "0.3.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",
@@ -33,6 +33,7 @@
     "lint": "eslint src server bin --ext .ts,.tsx"
   },
   "dependencies": {
+    "@google/genai": "^1.42.0",
     "@modelcontextprotocol/sdk": "^1.12.1",
     "@tiptap/core": "^3.0.0",
     "@tiptap/extension-code-block-lowlight": "^3.19.0",

package/skill/SKILL.md

@@ -23,7 +23,7 @@ You are a writing collaborator. You read documents and make edits **exclusively
 
 ## Setup — Which Path?
 
-Check whether the `open-writer` MCP tools are available (e.g. `read_pad`, `write_to_pad`). This determines setup state:
+Check whether the `openwriter` MCP tools are available (e.g. `read_pad`, `write_to_pad`). This determines setup state:
 
 ### MCP tools ARE available (ready to use)
 
@@ -38,11 +38,14 @@ Skip to [Writing Strategy](#writing-strategy) below.
 
 The user installed this skill from a directory but hasn't set up the MCP server yet. OpenWriter needs an MCP server to provide the 24 editing tools.
 
-**Step 1:** Tell the user to install the npm package and MCP server:
+**Step 1:** Tell the user to install globally and add the MCP server:
 
 ```bash
+# Install globally for instant startup (no npx resolution delay)
+npm install -g openwriter
+
 # Add the OpenWriter MCP server to Claude Code
-claude mcp add -s user open-writer -- npx openwriter --no-open
+claude mcp add -s user openwriter -- openwriter --no-open
 ```
 
 Then restart the Claude Code session. The MCP tools become available on next launch.
@@ -50,9 +53,9 @@ Then restart the Claude Code session. The MCP tools become available on next lau
 **Step 2 (if the user can't run the command above):** Edit `~/.claude.json` directly. Add to the `mcpServers` object:
 
 ```json
-"open-writer": {
-  "command": "npx",
-  "args": ["openwriter", "--no-open"]
+"openwriter": {
+  "command": "openwriter",
+  "args": ["--no-open"]
 }
 ```
 
@@ -61,9 +64,9 @@ The `mcpServers` key is at the top level of `~/.claude.json`. If it doesn't exis
 ```json
 {
   "mcpServers": {
-    "open-writer": {
-      "command": "npx",
-      "args": ["openwriter", "--no-open"]
+    "openwriter": {
+      "command": "openwriter",
+      "args": ["--no-open"]
     }
   }
 }
@@ -254,4 +257,4 @@ When importing or organizing book-length projects, read the source material firs
 
 **"pendingChanges" never clears** — User needs to accept/reject changes in the browser at http://localhost:5050.
 
-**Server not starting** — Ensure `npx openwriter` works from your terminal. If on Windows and using `npx`, the MCP config may need `"command": "cmd"` with `"args": ["/c", "npx", "openwriter", "--no-open"]`.
+**Server not starting** — Ensure `openwriter` works from your terminal (`npm install -g openwriter` first). If on Windows and the global command isn't found, the MCP config may need `"command": "cmd"` with `"args": ["/c", "openwriter", "--no-open"]`.