openwriter 0.2.0 → 0.2.2

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;
+    }
+}

package/dist/server/plugin-manager.js

@@ -0,0 +1,155 @@
+/**
+ * Plugin Manager: dynamic enable/disable, config persistence, route management.
+ * Replaces the one-shot loadPlugins() with a full lifecycle manager.
+ */
+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 { broadcastPluginsChanged } from './ws.js';
+export class PluginManager {
+    app;
+    plugins = new Map();
+    constructor(app) {
+        this.app = app;
+    }
+    /** Scan plugins/ directory and build the available plugins map. */
+    async discover() {
+        const discovered = discoverPlugins();
+        const savedConfig = readConfig();
+        const savedPlugins = savedConfig.plugins || {};
+        for (const d of discovered) {
+            // Load module to get configSchema
+            const loaded = await loadPluginModule(d.name);
+            const saved = savedPlugins[d.name];
+            this.plugins.set(d.name, {
+                discovered: d,
+                plugin: loaded?.plugin,
+                configSchema: loaded?.configSchema || {},
+                enabled: false,
+                config: saved?.config || {},
+                toolNames: [],
+            });
+        }
+    }
+    /** Enable a plugin: import, register routes + tools, save state. */
+    async enable(name) {
+        const managed = this.plugins.get(name);
+        if (!managed)
+            return { success: false, error: `Plugin "${name}" not found` };
+        if (managed.enabled)
+            return { success: true };
+        // Ensure plugin module is loaded
+        if (!managed.plugin) {
+            const loaded = await loadPluginModule(name);
+            if (!loaded)
+                return { success: false, error: `Failed to import "${name}"` };
+            managed.plugin = loaded.plugin;
+            managed.configSchema = loaded.configSchema;
+        }
+        if (!managed.plugin)
+            return { success: false, error: `Plugin "${name}" failed to load` };
+        const plugin = managed.plugin;
+        // Resolve config: saved config → env vars → empty
+        const resolvedConfig = this.resolveConfig(managed);
+        // Register routes via togglable middleware
+        if (plugin.registerRoutes) {
+            const router = createRouter();
+            await plugin.registerRoutes({ app: router, config: resolvedConfig });
+            managed.router = router;
+            // Wrap in middleware that skips when disabled
+            managed.middleware = (req, res, next) => {
+                if (!managed.enabled)
+                    return next();
+                managed.router(req, res, next);
+            };
+            this.app.use(managed.middleware);
+        }
+        // Register MCP tools
+        if (plugin.mcpTools) {
+            const tools = plugin.mcpTools(resolvedConfig);
+            managed.toolNames = tools.map((t) => t.name);
+            registerPluginTools(tools);
+        }
+        managed.enabled = true;
+        managed.config = resolvedConfig;
+        this.savePluginState();
+        broadcastPluginsChanged();
+        console.log(`[PluginManager] Enabled: ${plugin.name} v${plugin.version}`);
+        return { success: true };
+    }
+    /** Disable a plugin: skip routes, remove tools, save state. */
+    async disable(name) {
+        const managed = this.plugins.get(name);
+        if (!managed)
+            return { success: false, error: `Plugin "${name}" not found` };
+        if (!managed.enabled)
+            return { success: true };
+        // Remove MCP tools
+        if (managed.toolNames.length > 0) {
+            removePluginTools(managed.toolNames);
+            managed.toolNames = [];
+        }
+        managed.enabled = false;
+        this.savePluginState();
+        broadcastPluginsChanged();
+        console.log(`[PluginManager] Disabled: ${name}`);
+        return { success: true };
+    }
+    /** Update plugin config values and save. */
+    updateConfig(name, values) {
+        const managed = this.plugins.get(name);
+        if (!managed)
+            return { success: false, error: `Plugin "${name}" not found` };
+        managed.config = { ...managed.config, ...values };
+        this.savePluginState();
+        return { success: true };
+    }
+    /** Get all discovered plugins with status and config info. */
+    getAvailablePlugins() {
+        return Array.from(this.plugins.values()).map((m) => ({
+            name: m.discovered.name,
+            version: m.discovered.version,
+            description: m.discovered.description,
+            enabled: m.enabled,
+            configSchema: m.configSchema,
+            config: m.config,
+        }));
+    }
+    /** Get enabled plugins' context menu items (backward-compatible with GET /api/plugins). */
+    getEnabledPluginDescriptors() {
+        const results = [];
+        for (const managed of this.plugins.values()) {
+            if (!managed.enabled || !managed.plugin)
+                continue;
+            results.push({
+                name: managed.plugin.name,
+                contextMenuItems: managed.plugin.contextMenuItems?.() || [],
+            });
+        }
+        return results;
+    }
+    /** Resolve config values: saved config → env vars → empty. */
+    resolveConfig(managed) {
+        const resolved = { ...managed.config };
+        for (const [key, field] of Object.entries(managed.configSchema)) {
+            if (resolved[key])
+                continue;
+            const envVal = field.env ? process.env[field.env] : undefined;
+            if (envVal)
+                resolved[key] = envVal;
+        }
+        return resolved;
+    }
+    /** Persist enabled/config state to ~/.openwriter/config.json. */
+    savePluginState() {
+        const pluginsState = {};
+        for (const [name, managed] of this.plugins) {
+            pluginsState[name] = {
+                enabled: managed.enabled,
+                config: managed.config,
+            };
+        }
+        saveConfig({ plugins: pluginsState });
+    }
+}

package/dist/server/state.js

@@ -8,7 +8,7 @@ import { join } from 'path';
 import matter from 'gray-matter';
 import { tiptapToMarkdown, markdownToTiptap } from './markdown.js';
 import { applyTextEditsToNode } from './text-edit.js';
-import { DATA_DIR, TEMP_PREFIX, ensureDataDir, filePathForTitle, tempFilePath, generateNodeId, LEAF_BLOCK_TYPES, isExternalDoc } from './helpers.js';
+import { DATA_DIR, TEMP_PREFIX, ensureDataDir, filePathForTitle, tempFilePath, generateNodeId, LEAF_BLOCK_TYPES, resolveDocPath, isExternalDoc } from './helpers.js';
 import { snapshotIfNeeded, ensureDocId } from './versions.js';
 const DEFAULT_DOC = {
     type: 'doc',
@@ -213,7 +213,7 @@ function transferPendingAttrs(source, target) {
 const AGENT_LOCK_MS = 5000; // Block browser doc-updates for 5s after agent write
 let lastAgentWriteTime = 0;
 /** Set the agent write lock (called after agent changes). */
-function setAgentLock() {
+export function setAgentLock() {
     lastAgentWriteTime = Date.now();
 }
 /** Check if the agent write lock is active. */
@@ -249,7 +249,20 @@ export function applyChanges(changes) {
     }
     // Debounced save — coalesces rapid agent writes into a single disk write
     debouncedSave();
-    return processed.length;
+    // Find the last created node ID for chaining inserts
+    let lastNodeId = null;
+    for (let i = processed.length - 1; i >= 0; i--) {
+        const change = processed[i];
+        if (change.content) {
+            const contentArr = Array.isArray(change.content) ? change.content : [change.content];
+            const lastNode = contentArr[contentArr.length - 1];
+            if (lastNode?.attrs?.id) {
+                lastNodeId = lastNode.attrs.id;
+                break;
+            }
+        }
+    }
+    return { count: processed.length, lastNodeId };
 }
 export function onChanges(listener) {
     listeners.add(listener);
@@ -264,6 +277,14 @@ export function onChanges(listener) {
  * Returns the parent array and index for in-place mutation.
  */
 function findNodeInDoc(nodes, id) {
+    // Special sentinel: "end" resolves to the last top-level node in the document
+    if (id === 'end') {
+        const topLevel = state.document.content;
+        if (topLevel && topLevel.length > 0) {
+            return { parent: topLevel, index: topLevel.length - 1 };
+        }
+        return null;
+    }
     for (let i = 0; i < nodes.length; i++) {
         if (nodes[i].attrs?.id === id) {
             return { parent: nodes, index: i };
@@ -307,9 +328,9 @@ function applyChangesToDocument(changes) {
                 attrs: {
                     ...node.attrs,
                     id: node.attrs?.id || generateNodeId(),
-                    pendingStatus: 'insert',
                 },
             }));
+            markLeafBlocksAsPending(extraNodes, 'insert');
             found.parent.splice(found.index, 1, firstNode, ...extraNodes);
             processed.push({
                 ...change,
@@ -324,9 +345,10 @@ function applyChangesToDocument(changes) {
                 attrs: {
                     ...node.attrs,
                     id: node.attrs?.id || (change.nodeId && !change.afterNodeId && i === 0 ? change.nodeId : generateNodeId()),
-                    pendingStatus: 'insert',
                 },
             }));
+            // Mark leaf blocks as pending (not containers) for correct serialization
+            markLeafBlocksAsPending(contentWithIds, 'insert');
             if (change.nodeId && !change.afterNodeId) {
                 // Replace empty node
                 const found = findNodeInDoc(state.document.content, change.nodeId);
@@ -440,31 +462,28 @@ export function stripPendingAttrs() {
     strip(state.document.content);
 }
 /**
- * Mark leaf block nodes as pending. Only marks text-containing blocks
- * (paragraph, heading, codeBlock, horizontalRule) — NOT container nodes
- * (bulletList, orderedList, listItem, blockquote) whose children get marked instead.
- * This prevents overlapping decorations and ensures accept/reject acts on visible blocks.
+ * Mark leaf block nodes as pending within a node array.
+ * Only marks text-containing blocks (paragraph, heading, codeBlock, etc.)
+ * NOT container nodes (bulletList, orderedList, listItem, blockquote).
+ * This ensures collectPendingState captures them correctly on save.
  */
-export function markAllNodesAsPending(doc, status) {
-    function mark(nodes) {
-        if (!nodes)
-            return;
-        for (const node of nodes) {
-            if (node.type && LEAF_BLOCK_TYPES.has(node.type)) {
-                node.attrs = { ...node.attrs, pendingStatus: status };
-                if (!node.attrs.id) {
-                    node.attrs.id = generateNodeId();
-                }
-                // Don't recurse into leaf blocks — prevents overlapping decorations
-                // (e.g. table marked + its inner paragraphs also marked)
-            }
-            else if (node.content) {
-                // Recurse into container children to mark nested leaf blocks (e.g. paragraphs inside listItems)
-                mark(node.content);
+function markLeafBlocksAsPending(nodes, status) {
+    if (!nodes)
+        return;
+    for (const node of nodes) {
+        if (node.type && LEAF_BLOCK_TYPES.has(node.type)) {
+            node.attrs = { ...node.attrs, pendingStatus: status };
+            if (!node.attrs.id) {
+                node.attrs.id = generateNodeId();
             }
         }
+        else if (node.content) {
+            markLeafBlocksAsPending(node.content, status);
+        }
     }
-    mark(doc.content);
+}
+export function markAllNodesAsPending(doc, status) {
+    markLeafBlocksAsPending(doc.content, status);
 }
 /** Get filenames of all docs with pending changes (disk scan + external docs + current in-memory doc). */
 export function getPendingDocFilenames() {
@@ -747,3 +766,155 @@ function cleanupEmptyTempFiles() {
     }
     catch { /* ignore errors during cleanup */ }
 }
+// ============================================================================
+// DOCUMENT-LEVEL TAG OPERATIONS
+// ============================================================================
+/** Get tags for the active document from its metadata. */
+export function getDocTags() {
+    const tags = state.metadata.tags;
+    return Array.isArray(tags) ? tags : [];
+}
+/** Get tags for any document by filename (reads from disk if not active). */
+export function getDocTagsByFilename(filename) {
+    // If it's the active doc, use in-memory state
+    const activeFilename = state.filePath
+        ? (isExternalDoc(state.filePath) ? state.filePath : state.filePath.split(/[/\\]/).pop() || '')
+        : '';
+    if (filename === activeFilename)
+        return getDocTags();
+    // Otherwise read from disk
+    const targetPath = resolveDocPath(filename);
+    if (!existsSync(targetPath))
+        return [];
+    try {
+        const raw = readFileSync(targetPath, 'utf-8');
+        const { data } = matter(raw);
+        return Array.isArray(data.tags) ? data.tags : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** Add a tag to a document. Works on active doc or any file on disk. */
+export function addDocTag(filename, tag) {
+    const activeFilename = state.filePath
+        ? (isExternalDoc(state.filePath) ? state.filePath : state.filePath.split(/[/\\]/).pop() || '')
+        : '';
+    if (filename === activeFilename) {
+        // Active doc — update in-memory metadata
+        const tags = Array.isArray(state.metadata.tags) ? [...state.metadata.tags] : [];
+        if (!tags.includes(tag)) {
+            tags.push(tag);
+            state.metadata.tags = tags;
+            save();
+        }
+    }
+    else {
+        // Non-active doc — read/write disk
+        const targetPath = resolveDocPath(filename);
+        if (!existsSync(targetPath))
+            return;
+        try {
+            const raw = readFileSync(targetPath, 'utf-8');
+            const parsed = markdownToTiptap(raw);
+            const tags = Array.isArray(parsed.metadata.tags) ? [...parsed.metadata.tags] : [];
+            if (!tags.includes(tag)) {
+                tags.push(tag);
+                parsed.metadata.tags = tags;
+                const markdown = tiptapToMarkdown(parsed.document, parsed.title, parsed.metadata);
+                writeFileSync(targetPath, markdown, 'utf-8');
+            }
+        }
+        catch { /* best-effort */ }
+    }
+}
+/** Remove a tag from a document. Works on active doc or any file on disk. */
+export function removeDocTag(filename, tag) {
+    const activeFilename = state.filePath
+        ? (isExternalDoc(state.filePath) ? state.filePath : state.filePath.split(/[/\\]/).pop() || '')
+        : '';
+    if (filename === activeFilename) {
+        const tags = Array.isArray(state.metadata.tags) ? [...state.metadata.tags] : [];
+        const idx = tags.indexOf(tag);
+        if (idx >= 0) {
+            tags.splice(idx, 1);
+            state.metadata.tags = tags.length > 0 ? tags : undefined;
+            save();
+        }
+    }
+    else {
+        const targetPath = resolveDocPath(filename);
+        if (!existsSync(targetPath))
+            return;
+        try {
+            const raw = readFileSync(targetPath, 'utf-8');
+            const parsed = markdownToTiptap(raw);
+            const tags = Array.isArray(parsed.metadata.tags) ? [...parsed.metadata.tags] : [];
+            const idx = tags.indexOf(tag);
+            if (idx >= 0) {
+                tags.splice(idx, 1);
+                parsed.metadata.tags = tags.length > 0 ? tags : undefined;
+                const markdown = tiptapToMarkdown(parsed.document, parsed.title, parsed.metadata);
+                writeFileSync(targetPath, markdown, 'utf-8');
+            }
+        }
+        catch { /* best-effort */ }
+    }
+}
+// ============================================================================
+// CROSS-DOCUMENT HELPERS (operate on specific files, not the active singleton)
+// ============================================================================
+/**
+ * Save a browser doc-update to a specific file on disk.
+ * Used when the browser sends a doc-update for a non-active document (race condition guard).
+ */
+export function saveDocToFile(filename, doc) {
+    const targetPath = resolveDocPath(filename);
+    if (!existsSync(targetPath))
+        return; // Target doesn't exist, nothing to save to
+    try {
+        const raw = readFileSync(targetPath, 'utf-8');
+        const parsed = markdownToTiptap(raw);
+        // Transfer pending attrs from on-disk version to the incoming doc
+        if (hasPendingChanges(parsed.document)) {
+            transferPendingAttrs(parsed.document, doc);
+        }
+        const markdown = tiptapToMarkdown(doc, parsed.title, parsed.metadata);
+        writeFileSync(targetPath, markdown, 'utf-8');
+    }
+    catch { /* best-effort */ }
+}
+/**
+ * Strip pending attrs from a specific file on disk (not the active document).
+ * Optionally clears agentCreated metadata (on accept).
+ */
+export function stripPendingAttrsFromFile(filename, clearAgentCreated) {
+    const targetPath = resolveDocPath(filename);
+    if (!existsSync(targetPath))
+        return;
+    try {
+        const raw = readFileSync(targetPath, 'utf-8');
+        const parsed = markdownToTiptap(raw);
+        // Strip pending attrs from the parsed document
+        function strip(nodes) {
+            if (!nodes)
+                return;
+            for (const node of nodes) {
+                if (node.attrs?.pendingStatus) {
+                    delete node.attrs.pendingStatus;
+                    delete node.attrs.pendingOriginalContent;
+                    delete node.attrs.pendingTextEdits;
+                }
+                if (node.content)
+                    strip(node.content);
+            }
+        }
+        strip(parsed.document.content);
+        if (clearAgentCreated && parsed.metadata.agentCreated) {
+            delete parsed.metadata.agentCreated;
+        }
+        const markdown = tiptapToMarkdown(parsed.document, parsed.title, parsed.metadata);
+        writeFileSync(targetPath, markdown, 'utf-8');
+    }
+    catch { /* best-effort */ }
+}

package/dist/server/workspace-routes.js

@@ -3,7 +3,7 @@
  * Mounted in index.ts to keep the main file lean.
  */
 import { Router } from 'express';
-import { listWorkspaces, getWorkspace, createWorkspace, deleteWorkspace, reorderWorkspaces, addDoc, removeDoc, moveDoc, reorderDoc, addContainerToWorkspace, removeContainer, renameContainer, reorderContainer, tagDoc, untagDoc, } from './workspaces.js';
+import { listWorkspaces, getWorkspace, createWorkspace, deleteWorkspace, reorderWorkspaces, addDoc, removeDoc, moveDoc, reorderDoc, addContainerToWorkspace, removeContainer, renameContainer, reorderContainer, } from './workspaces.js';
 export function createWorkspaceRouter(b) {
     const router = Router();
     router.get('/api/workspaces', (_req, res) => {
@@ -30,9 +30,9 @@ export function createWorkspaceRouter(b) {
             res.status(404).json({ error: err.message });
         }
     });
-    router.delete('/api/workspaces/:filename', (req, res) => {
+    router.delete('/api/workspaces/:filename', async (req, res) => {
         try {
-            deleteWorkspace(req.params.filename);
+            await deleteWorkspace(req.params.filename);
             b.broadcastWorkspacesChanged();
             res.json({ success: true });
         }
@@ -138,27 +138,6 @@ export function createWorkspaceRouter(b) {
             res.status(400).json({ error: err.message });
         }
     });
-    // Tag operations
-    router.post('/api/workspaces/:filename/tags/:docFile', (req, res) => {
-        try {
-            const ws = tagDoc(req.params.filename, req.params.docFile, req.body.tag);
-            b.broadcastWorkspacesChanged();
-            res.json(ws);
-        }
-        catch (err) {
-            res.status(400).json({ error: err.message });
-        }
-    });
-    router.delete('/api/workspaces/:filename/tags/:docFile/:tag', (req, res) => {
-        try {
-            const ws = untagDoc(req.params.filename, req.params.docFile, req.params.tag);
-            b.broadcastWorkspacesChanged();
-            res.json(ws);
-        }
-        catch (err) {
-            res.status(400).json({ error: err.message });
-        }
-    });
     // Cross-workspace move (from one workspace to another)
     router.post('/api/workspaces/:targetFilename/docs/:docFile/cross-move', (req, res) => {
         try {

package/dist/server/workspace-tags.js

@@ -20,9 +20,6 @@ export function removeFileFromAllTags(tags, file) {
         removeTag(tags, tagName, file);
     }
 }
-export function listFilesForTag(tags, tagName) {
-    return tags[tagName] || [];
-}
 export function listTagsForFile(tags, file) {
     const result = [];
     for (const [tagName, files] of Object.entries(tags)) {

package/dist/server/workspace-types.js

@@ -10,23 +10,15 @@ export function isV1(data) {
     return !data.version || data.version < 2;
 }
 export function migrateV1toV2(legacy) {
-    const tags = {};
     const root = [];
     for (const item of legacy.items || []) {
         root.push({ type: 'doc', file: item.file, title: item.file.replace(/\.md$/, '') });
-        if (item.tag) {
-            if (!tags[item.tag])
-                tags[item.tag] = [];
-            if (!tags[item.tag].includes(item.file))
-                tags[item.tag].push(item.file);
-        }
     }
     return {
         version: 2,
         title: legacy.title,
         voiceProfileId: legacy.voiceProfileId ?? null,
         root,
-        tags,
         context: legacy.context,
     };
 }