openwriter 0.5.1 → 0.5.3

package/dist/server/index.js

@@ -7,13 +7,12 @@ import { createServer } from 'http';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { existsSync, readFileSync } from 'fs';
-import { setupWebSocket, broadcastAgentStatus, broadcastDocumentSwitched, broadcastDocumentsChanged, broadcastWorkspacesChanged, broadcastMetadataChanged, broadcastPendingDocsChanged, broadcastSyncStatus, broadcastWritingStarted, broadcastWritingFinished } from './ws.js';
+import { setupWebSocket, broadcastAgentStatus, broadcastDocumentSwitched, broadcastDocumentsChanged, broadcastWorkspacesChanged, broadcastMetadataChanged, broadcastPendingDocsChanged, broadcastSyncStatus, broadcastWritingStarted, broadcastWritingFinished, broadcastMarksChanged } from './ws.js';
 import { TOOL_REGISTRY } from './mcp.js';
 import { z } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 import { save, getDocument, getTitle, getFilePath, getDocId, getMetadata, getStatus, updateDocument, setMetadata, applyTextEdits, isAgentLocked, getPendingDocInfo, getDocTagsByFilename, addDocTag, removeDocTag, markAllNodesAsPending, updatePendingCacheForActiveDoc } from './state.js';
-import { listDocuments, switchDocument, createDocument, deleteDocument, duplicateDocument, reloadDocument, updateDocumentTitle, openFile, reorderDocs } from './documents.js';
-import { writePromptDebug } from './prompt-debug.js';
+import { listDocuments, switchDocument, createDocument, deleteDocument, duplicateDocument, reloadDocument, updateDocumentTitle, openFile, reorderDocs, searchDocuments, listArchivedDocuments, archiveDocument, unarchiveDocument } from './documents.js';
 import { createWorkspaceRouter } from './workspace-routes.js';
 import { createLinkRouter } from './link-routes.js';
 import { createTweetRouter } from './tweet-routes.js';
@@ -27,6 +26,7 @@ import { createImageRouter } from './image-upload.js';
 import { createExportRouter } from './export-routes.js';
 import { PluginManager } from './plugin-manager.js';
 import { checkForUpdate } from './update-check.js';
+import { addMark, getMarks, resolveMarks } from './marks.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 export async function startHttpServer(options = {}) {
@@ -55,7 +55,14 @@ export async function startHttpServer(options = {}) {
                 res.status(404).json({ error: `Unknown tool: ${toolName}` });
                 return;
             }
-            const result = await tool.handler(args || {});
+            // Validate arguments against the tool's Zod schema (mirrors McpServer.validateToolInput)
+            const schema = z.object(tool.schema);
+            const parsed = schema.safeParse(args || {});
+            if (!parsed.success) {
+                res.status(400).json({ content: [{ type: 'text', text: `Validation error: ${parsed.error.message}` }] });
+                return;
+            }
+            const result = await tool.handler(parsed.data);
             res.json(result);
         }
         catch (err) {
@@ -222,6 +229,39 @@ export async function startHttpServer(options = {}) {
             res.status(500).json({ error: err.message });
         }
     });
+    app.get('/api/documents/archived', (_req, res) => {
+        res.json(listArchivedDocuments());
+    });
+    app.get('/api/documents/search', (req, res) => {
+        const q = req.query.q || '';
+        const includeArchived = req.query.archived === 'true';
+        res.json(searchDocuments(q, includeArchived));
+    });
+    app.post('/api/documents/:filename/archive', (req, res) => {
+        try {
+            removeDocFromAllWorkspaces(req.params.filename);
+            const result = archiveDocument(req.params.filename);
+            if (result.switched && result.newDoc) {
+                broadcastDocumentSwitched(result.newDoc.document, result.newDoc.title, result.newDoc.filename);
+            }
+            broadcastDocumentsChanged();
+            broadcastWorkspacesChanged();
+            res.json(result);
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+        }
+    });
+    app.post('/api/documents/:filename/unarchive', (req, res) => {
+        try {
+            const result = unarchiveDocument(req.params.filename);
+            broadcastDocumentsChanged();
+            res.json(result);
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+        }
+    });
     app.get('/api/documents/:filename/content', (req, res) => {
         try {
             const targetPath = resolveDocPath(req.params.filename);
@@ -296,6 +336,45 @@ export async function startHttpServer(options = {}) {
             res.status(400).json({ error: err.message });
         }
     });
+    // Agent marks
+    app.post('/api/marks', (req, res) => {
+        try {
+            const { filename, text, note, nodeId } = req.body;
+            if (!filename || !text || !nodeId) {
+                res.status(400).json({ error: 'filename, text, and nodeId are required' });
+                return;
+            }
+            const mark = addMark(filename, text, note || '', nodeId);
+            broadcastMarksChanged(filename);
+            res.json({ success: true, mark });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.get('/api/marks/:filename', (req, res) => {
+        try {
+            const marks = getMarks(req.params.filename);
+            res.json({ marks: marks[req.params.filename] || [] });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.delete('/api/marks', (req, res) => {
+        try {
+            const { ids } = req.body;
+            if (!Array.isArray(ids)) {
+                res.status(400).json({ error: 'ids must be an array' });
+                return;
+            }
+            const resolved = resolveMarks(ids);
+            res.json({ success: true, resolved });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     // Mount workspace CRUD + doc/container routes
     app.use(createWorkspaceRouter({ broadcastWorkspacesChanged }));
     // Mount link-doc routes (create-link-doc, auto-tag-link)
@@ -321,22 +400,6 @@ export async function startHttpServer(options = {}) {
             res.status(500).json({ error: err.message });
         }
     });
-    // Prompt debug: write full prompt to a timestamped .md file for inspection
-    app.post('/api/prompt-debug', (req, res) => {
-        try {
-            const { action, debug, metadata } = req.body;
-            if (!debug) {
-                res.status(400).json({ error: 'debug payload is required' });
-                return;
-            }
-            const filename = writePromptDebug(action, debug, metadata);
-            broadcastDocumentsChanged();
-            res.json({ success: true, filename });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
-    });
     // Google Doc import
     app.post('/api/import/gdoc', (req, res) => {
         try {
@@ -478,28 +541,31 @@ export async function startHttpServer(options = {}) {
             res.sendFile(join(clientDir, 'index.html'));
         });
     }
-    else {
-        // Dev mode: proxy to Vite
-        app.get('/', (_req, res) => {
-            res.send(`
-        <html>
-          <body style="display:flex;align-items:center;justify-content:center;height:100vh;font-family:sans-serif">
-            <div style="text-align:center">
-              <h2>OpenWriter Server Running</h2>
-              <p>In development, run <code>npm run dev:client</code> and visit <a href="http://localhost:5173">localhost:5173</a></p>
-            </div>
-          </body>
-        </html>
-      `);
-        });
-    }
     const server = createServer(app);
     // Setup WebSocket on same server
     setupWebSocket(server);
     // Broadcast agent status now that WS is ready
     broadcastAgentStatus(true);
-    server.listen(port, '127.0.0.1', () => {
-        console.log(`OpenWriter running at http://localhost:${port}`);
+    await new Promise((resolve, reject) => {
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                console.error(`[HTTP] Port ${port} in use — retrying in 2s...`);
+                setTimeout(() => {
+                    server.listen(port, '127.0.0.1', () => {
+                        console.log(`OpenWriter running at http://localhost:${port}`);
+                        resolve();
+                    });
+                }, 2000);
+            }
+            else {
+                console.error(`[HTTP] Server error:`, err);
+                reject(err);
+            }
+        });
+        server.listen(port, '127.0.0.1', () => {
+            console.log(`OpenWriter running at http://localhost:${port}`);
+            resolve();
+        });
     });
     // Open browser unless --no-open or running as MCP stdio pipe
     const isMcpStdio = !process.stdout.isTTY;

package/dist/server/marks.js

@@ -0,0 +1,166 @@
+/**
+ * Agent Marks: sidecar JSON storage for inline user feedback.
+ * Each document gets a sidecar file at DATA_DIR/_marks/{filename}.json.
+ */
+import { join } from 'path';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, unlinkSync, renameSync } from 'fs';
+import { randomUUID } from 'crypto';
+import { DATA_DIR, ensureDataDir } from './helpers.js';
+const MARKS_DIR = join(DATA_DIR, '_marks');
+function ensureMarksDir() {
+    ensureDataDir();
+    if (!existsSync(MARKS_DIR))
+        mkdirSync(MARKS_DIR, { recursive: true });
+}
+function markFilePath(filename) {
+    // Sanitize: replace path separators to avoid nested paths
+    const safe = filename.replace(/[/\\]/g, '_');
+    return join(MARKS_DIR, `${safe}.json`);
+}
+function readMarkFile(filename) {
+    const path = markFilePath(filename);
+    if (!existsSync(path))
+        return { marks: [] };
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return { marks: [] };
+    }
+}
+function writeMarkFile(filename, data) {
+    ensureMarksDir();
+    const path = markFilePath(filename);
+    if (data.marks.length === 0) {
+        // Clean up empty sidecar files
+        if (existsSync(path))
+            unlinkSync(path);
+        return;
+    }
+    writeFileSync(path, JSON.stringify(data, null, 2));
+}
+export function addMark(filename, text, note, nodeId) {
+    const data = readMarkFile(filename);
+    const mark = {
+        id: randomUUID().slice(0, 8),
+        text,
+        note,
+        nodeId,
+        createdAt: new Date().toISOString(),
+    };
+    data.marks.push(mark);
+    writeMarkFile(filename, data);
+    return mark;
+}
+export function getMarks(filename) {
+    if (filename) {
+        const data = readMarkFile(filename);
+        if (data.marks.length === 0)
+            return {};
+        return { [filename]: data.marks };
+    }
+    // All docs: scan _marks directory
+    ensureMarksDir();
+    const result = {};
+    try {
+        const files = readdirSync(MARKS_DIR);
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            const docFilename = file.replace(/\.json$/, '').replace(/_/g, ' ');
+            // Read raw to avoid filename roundtrip issues
+            const path = join(MARKS_DIR, file);
+            try {
+                const data = JSON.parse(readFileSync(path, 'utf-8'));
+                if (data.marks.length > 0)
+                    result[docFilename] = data.marks;
+            }
+            catch { /* skip corrupt files */ }
+        }
+    }
+    catch { /* dir doesn't exist yet */ }
+    return result;
+}
+export function getMarkCount(filename) {
+    return readMarkFile(filename).marks.length;
+}
+/** Count marks across all documents, optionally excluding one filename. */
+export function getGlobalMarkSummary(excludeFilename) {
+    ensureMarksDir();
+    let totalMarks = 0;
+    let docCount = 0;
+    try {
+        const files = readdirSync(MARKS_DIR);
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            if (excludeFilename) {
+                const safe = excludeFilename.replace(/[/\\]/g, '_');
+                if (file === `${safe}.json`)
+                    continue;
+            }
+            const path = join(MARKS_DIR, file);
+            try {
+                const data = JSON.parse(readFileSync(path, 'utf-8'));
+                if (data.marks.length > 0) {
+                    totalMarks += data.marks.length;
+                    docCount++;
+                }
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch { /* dir doesn't exist */ }
+    return { totalMarks, docCount };
+}
+export function resolveMarks(ids) {
+    const idSet = new Set(ids);
+    const resolved = [];
+    ensureMarksDir();
+    try {
+        const files = readdirSync(MARKS_DIR);
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            const filePath = join(MARKS_DIR, file);
+            try {
+                const data = JSON.parse(readFileSync(filePath, 'utf-8'));
+                const before = data.marks.length;
+                data.marks = data.marks.filter((m) => {
+                    if (idSet.has(m.id)) {
+                        resolved.push(m.id);
+                        return false;
+                    }
+                    return true;
+                });
+                if (data.marks.length !== before) {
+                    const docFilename = file.replace(/\.json$/, '').replace(/_/g, ' ');
+                    writeMarkFile(docFilename, data);
+                }
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch { /* dir doesn't exist */ }
+    return resolved;
+}
+export function pruneStaleMarks(filename, validNodeIds) {
+    const data = readMarkFile(filename);
+    if (data.marks.length === 0)
+        return 0;
+    const validSet = new Set(validNodeIds);
+    const before = data.marks.length;
+    data.marks = data.marks.filter((m) => validSet.has(m.nodeId));
+    const pruned = before - data.marks.length;
+    if (pruned > 0)
+        writeMarkFile(filename, data);
+    return pruned;
+}
+/** Rename a mark sidecar file when a document is renamed. */
+export function renameMark(oldFilename, newFilename) {
+    const oldPath = markFilePath(oldFilename);
+    if (!existsSync(oldPath))
+        return;
+    const newPath = markFilePath(newFilename);
+    renameSync(oldPath, newPath);
+}