openwriter 0.1.0

package/dist/server/helpers.js

@@ -0,0 +1,87 @@
+/**
+ * Shared constants and utility functions for OpenWriter server.
+ * Both state.ts and documents.ts import from here to avoid duplication.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from 'fs';
+import { join, isAbsolute, basename, dirname } from 'path';
+import { homedir } from 'os';
+import { randomUUID } from 'crypto';
+export const DATA_DIR = join(homedir(), '.openwriter');
+export const VERSIONS_DIR = join(DATA_DIR, '.versions');
+export const WORKSPACES_DIR = join(DATA_DIR, '_workspaces');
+export const CONFIG_FILE = join(DATA_DIR, 'config.json');
+export const TEMP_PREFIX = '_untitled-';
+export function ensureDataDir() {
+    if (!existsSync(DATA_DIR)) {
+        // One-time migration: rename ~/.superwriter/ → ~/.openwriter/
+        const legacyDir = join(homedir(), '.superwriter');
+        if (existsSync(legacyDir)) {
+            renameSync(legacyDir, DATA_DIR);
+        }
+        else {
+            mkdirSync(DATA_DIR, { recursive: true });
+        }
+    }
+}
+export function ensureWorkspacesDir() {
+    ensureDataDir();
+    if (!existsSync(WORKSPACES_DIR))
+        mkdirSync(WORKSPACES_DIR, { recursive: true });
+}
+export function sanitizeFilename(name) {
+    return name.replace(/[<>:"/\\|?*]/g, '-').trim() || 'Untitled';
+}
+export function filePathForTitle(title) {
+    return join(DATA_DIR, `${sanitizeFilename(title)}.md`);
+}
+export function tempFilePath() {
+    return join(DATA_DIR, `${TEMP_PREFIX}${randomUUID()}.md`);
+}
+// ---- Path resolution for external documents ----
+/** Resolve a filename to a full path. Basenames resolve to DATA_DIR; absolute paths pass through. */
+export function resolveDocPath(filename) {
+    if (isAbsolute(filename) || /[/\\]/.test(filename))
+        return filename;
+    return join(DATA_DIR, filename);
+}
+/** Returns true if filename is a full path (not a simple basename in DATA_DIR). */
+export function isExternalDoc(filename) {
+    if (isAbsolute(filename) || /[/\\]/.test(filename)) {
+        const resolved = isAbsolute(filename) ? filename : filename;
+        return !resolved.startsWith(DATA_DIR);
+    }
+    return false;
+}
+/** Extract basename from a path, or return as-is if already a basename. */
+export function getDocBasename(filename) {
+    return basename(filename);
+}
+/** Extract parent directory name from a path. Returns empty string for basenames. */
+export function getParentDirName(filename) {
+    if (!isAbsolute(filename) && !/[/\\]/.test(filename))
+        return '';
+    return basename(dirname(filename));
+}
+/** Generate an 8-char hex node ID for TipTap block nodes. */
+export function generateNodeId() {
+    return randomUUID().replace(/-/g, '').slice(0, 8);
+}
+/** Leaf block types: text-containing blocks that get pending decorations. */
+export const LEAF_BLOCK_TYPES = new Set(['paragraph', 'heading', 'codeBlock', 'horizontalRule', 'table', 'image']);
+export function readConfig() {
+    ensureDataDir();
+    if (!existsSync(CONFIG_FILE))
+        return {};
+    try {
+        return JSON.parse(readFileSync(CONFIG_FILE, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+export function saveConfig(updates) {
+    ensureDataDir();
+    const current = readConfig();
+    const merged = { ...current, ...updates };
+    writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2), 'utf-8');
+}

package/dist/server/image-upload.js

@@ -0,0 +1,55 @@
+/**
+ * Image upload and static serving for OpenWriter.
+ * Images are stored in {DATA_DIR}/_images/ and referenced as relative paths in markdown.
+ */
+import { Router } from 'express';
+import multer from 'multer';
+import { existsSync, mkdirSync } from 'fs';
+import { join, extname } from 'path';
+import { randomUUID } from 'crypto';
+import { DATA_DIR, ensureDataDir } from './helpers.js';
+import express from 'express';
+const IMAGES_DIR = join(DATA_DIR, '_images');
+function ensureImagesDir() {
+    ensureDataDir();
+    if (!existsSync(IMAGES_DIR))
+        mkdirSync(IMAGES_DIR, { recursive: true });
+}
+const storage = multer.diskStorage({
+    destination: (_req, _file, cb) => {
+        ensureImagesDir();
+        cb(null, IMAGES_DIR);
+    },
+    filename: (_req, file, cb) => {
+        const ext = extname(file.originalname) || '.png';
+        cb(null, `${randomUUID().slice(0, 8)}${ext}`);
+    },
+});
+const upload = multer({
+    storage,
+    limits: { fileSize: 10 * 1024 * 1024 }, // 10MB
+    fileFilter: (_req, file, cb) => {
+        if (file.mimetype.startsWith('image/')) {
+            cb(null, true);
+        }
+        else {
+            cb(new Error('Only image files are allowed'));
+        }
+    },
+});
+export function createImageRouter() {
+    const router = Router();
+    // Static serving for images
+    ensureImagesDir();
+    router.use('/_images', express.static(IMAGES_DIR));
+    // Upload endpoint
+    router.post('/api/upload-image', upload.single('image'), (req, res) => {
+        if (!req.file) {
+            res.status(400).json({ error: 'No image file provided' });
+            return;
+        }
+        const src = `/_images/${req.file.filename}`;
+        res.json({ src });
+    });
+    return router;
+}

package/dist/server/index.js

@@ -0,0 +1,315 @@
+/**
+ * Express server: serves built React app, WebSocket, orchestrates MCP.
+ */
+import express from 'express';
+import { createServer } from 'http';
+import { createConnection } from 'net';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { existsSync } from 'fs';
+import { setupWebSocket, broadcastAgentStatus, broadcastDocumentSwitched, broadcastDocumentsChanged, broadcastWorkspacesChanged, broadcastSyncStatus } from './ws.js';
+import { startMcpServer, TOOL_REGISTRY, registerPluginTools } from './mcp.js';
+import { startMcpClientServer } from './mcp-client.js';
+import { load, save, getDocument, getTitle, getFilePath, getDocId, getStatus, updateDocument, setMetadata, applyTextEdits, isAgentLocked, getPendingDocFilenames, getPendingDocCounts } from './state.js';
+import { listDocuments, switchDocument, createDocument, deleteDocument, reloadDocument, updateDocumentTitle, openFile } from './documents.js';
+import { createWorkspaceRouter } from './workspace-routes.js';
+import { createLinkRouter } from './link-routes.js';
+import { markdownToTiptap } from './markdown.js';
+import { importGoogleDoc } from './gdoc-import.js';
+import { createVersionRouter } from './version-routes.js';
+import { createSyncRouter } from './sync-routes.js';
+import { createImageRouter } from './image-upload.js';
+import { createExportRouter } from './export-routes.js';
+import { loadPlugins } from './plugin-loader.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+function isPortTaken(port) {
+    return new Promise((resolve) => {
+        const socket = createConnection({ port, host: '127.0.0.1' });
+        socket.once('connect', () => { socket.destroy(); resolve(true); });
+        socket.once('error', () => { resolve(false); });
+    });
+}
+export async function startServer(options = {}) {
+    const port = options.port || 5050;
+    // Check if another instance already owns the port
+    const portTaken = await isPortTaken(port);
+    if (portTaken) {
+        console.error(`[OpenWriter] Port ${port} in use — entering client mode (proxying to existing server)`);
+        // Start client-mode MCP (proxies tool calls via HTTP)
+        startMcpClientServer(port).catch((err) => {
+            console.error('[MCP-Client] Failed to start:', err);
+        });
+        // Skip browser open — existing server already has it open
+        return;
+    }
+    // Load saved document
+    load();
+    const app = express();
+    app.use(express.json({ limit: '10mb' }));
+    // API routes for direct HTTP access (fallback if WS not available)
+    app.get('/api/status', (_req, res) => {
+        res.json(getStatus());
+    });
+    // MCP-over-HTTP: allows client-mode terminals to proxy tool calls
+    app.post('/api/mcp-call', async (req, res) => {
+        try {
+            const { tool: toolName, arguments: args } = req.body;
+            const tool = TOOL_REGISTRY.find((t) => t.name === toolName);
+            if (!tool) {
+                res.status(404).json({ error: `Unknown tool: ${toolName}` });
+                return;
+            }
+            const result = await tool.handler(args || {});
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ content: [{ type: 'text', text: `Error: ${err.message}` }] });
+        }
+    });
+    app.get('/api/document', (_req, res) => {
+        res.json({ document: getDocument(), title: getTitle() });
+    });
+    app.get('/api/pending-docs', (_req, res) => {
+        res.json({
+            filenames: getPendingDocFilenames(),
+            counts: getPendingDocCounts(),
+        });
+    });
+    // Mount image upload + static serving
+    app.use(createImageRouter());
+    // Mount sync routes
+    app.use(createSyncRouter(broadcastSyncStatus));
+    // Mount export routes
+    app.use(createExportRouter());
+    // Mount version history routes
+    app.use(createVersionRouter({
+        getDocId,
+        getFilePath,
+        updateDocument,
+        save,
+        broadcastDocumentSwitched,
+    }));
+    app.post('/api/save', (_req, res) => {
+        save();
+        res.json({ success: true });
+    });
+    // Beacon-based flush: browser sends this on beforeunload/visibilitychange
+    // sendBeacon sends as text/plain, so we parse the JSON manually
+    app.post('/api/flush', express.text({ type: '*/*', limit: '10mb' }), (req, res) => {
+        try {
+            if (isAgentLocked()) {
+                console.log('[Flush] Blocked (agent write lock active)');
+                res.status(204).end();
+                return;
+            }
+            const msg = typeof req.body === 'string' ? JSON.parse(req.body) : req.body;
+            if (msg.document) {
+                updateDocument(msg.document);
+                save();
+            }
+            else if (msg.markdown) {
+                const parsed = markdownToTiptap(msg.markdown);
+                updateDocument(parsed.document);
+                if (parsed.title !== 'Untitled')
+                    setMetadata({ title: parsed.title });
+                save();
+            }
+            res.status(204).end();
+        }
+        catch {
+            res.status(400).end();
+        }
+    });
+    // Document CRUD routes
+    app.get('/api/documents', (_req, res) => {
+        res.json(listDocuments());
+    });
+    app.post('/api/documents', (req, res) => {
+        try {
+            const result = createDocument(req.body.title, req.body.content, req.body.path);
+            broadcastDocumentSwitched(result.document, result.title, result.filename);
+            res.json(result);
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+        }
+    });
+    app.post('/api/documents/open', (req, res) => {
+        try {
+            const { path } = req.body;
+            if (!path) {
+                res.status(400).json({ error: 'path is required' });
+                return;
+            }
+            const result = openFile(path);
+            broadcastDocumentSwitched(result.document, result.title, result.filename);
+            res.json(result);
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+        }
+    });
+    app.post('/api/documents/switch', (req, res) => {
+        try {
+            const result = switchDocument(req.body.filename);
+            broadcastDocumentSwitched(result.document, result.title, result.filename);
+            res.json(result);
+        }
+        catch (err) {
+            res.status(404).json({ error: err.message });
+        }
+    });
+    app.post('/api/documents/reload', (_req, res) => {
+        try {
+            const result = reloadDocument();
+            broadcastDocumentSwitched(result.document, result.title, result.filename);
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.delete('/api/documents/:filename', (req, res) => {
+        try {
+            const result = deleteDocument(req.params.filename);
+            if (result.switched && result.newDoc) {
+                broadcastDocumentSwitched(result.newDoc.document, result.newDoc.title, result.newDoc.filename);
+            }
+            else {
+                broadcastDocumentsChanged();
+            }
+            res.json(result);
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+        }
+    });
+    app.put('/api/documents/:filename', (req, res) => {
+        try {
+            // Title change = metadata only. Filename stays stable.
+            updateDocumentTitle(req.params.filename, req.body.title);
+            broadcastDocumentsChanged();
+            res.json({ filename: req.params.filename });
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+        }
+    });
+    // Mount workspace CRUD + doc/container/tag routes
+    app.use(createWorkspaceRouter({ broadcastWorkspacesChanged }));
+    // Mount link-doc routes (create-link-doc, auto-tag-link)
+    app.use(createLinkRouter({ broadcastDocumentsChanged, broadcastWorkspacesChanged }));
+    // Text edit (fine-grained find/replace + mark changes within a node)
+    app.post('/api/edit-text', (req, res) => {
+        try {
+            const { nodeId, edits } = req.body;
+            if (!nodeId || !edits) {
+                res.status(400).json({ error: 'nodeId and edits are required' });
+                return;
+            }
+            const result = applyTextEdits(nodeId, edits);
+            if (!result.success) {
+                res.status(400).json({ error: result.error });
+                return;
+            }
+            res.json({ success: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // Google Doc import
+    app.post('/api/import/gdoc', (req, res) => {
+        try {
+            const result = importGoogleDoc(req.body.document, req.body.title);
+            broadcastDocumentsChanged();
+            broadcastWorkspacesChanged();
+            res.json(result);
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+        }
+    });
+    // Load plugins
+    const pluginResult = await loadPlugins(options.plugins || [], options.pluginConfig || {});
+    for (const err of pluginResult.errors)
+        console.error(`[Plugin] ${err}`);
+    for (const { plugin, config } of pluginResult.plugins) {
+        if (plugin.registerRoutes)
+            await plugin.registerRoutes({ app, config });
+        if (plugin.mcpTools)
+            registerPluginTools(plugin.mcpTools(config));
+        console.log(`[Plugin] Loaded: ${plugin.name} v${plugin.version}`);
+    }
+    // Plugin discovery endpoint — client fetches to build dynamic context menu
+    app.get('/api/plugins', (_req, res) => {
+        const descriptors = pluginResult.plugins.map(({ plugin }) => ({
+            name: plugin.name,
+            contextMenuItems: plugin.contextMenuItems?.() || [],
+        }));
+        res.json({ plugins: descriptors });
+    });
+    // Plugin action dispatch — client sends action payload, routed to correct plugin
+    app.post('/api/plugin-action', async (req, res) => {
+        try {
+            const payload = req.body;
+            const prefix = payload.action.split(':')[0];
+            const loaded = pluginResult.plugins.find(({ plugin }) => plugin.contextMenuItems?.().some((item) => item.action.startsWith(prefix + ':')));
+            if (!loaded) {
+                res.status(404).json({ error: `No plugin handles action "${payload.action}"` });
+                return;
+            }
+            // Forward to plugin's registered route — plugins handle their own actions
+            // via routes registered in registerRoutes(). The client calls those directly.
+            res.status(404).json({ error: 'Use plugin-registered routes directly' });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // Serve built React app
+    const clientDir = join(__dirname, '..', 'client');
+    if (existsSync(clientDir)) {
+        app.use(express.static(clientDir));
+        app.get('*', (_req, res) => {
+            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);
+    // Start MCP stdio server (for agent connections)
+    startMcpServer().then(() => {
+        broadcastAgentStatus(true);
+    }).catch((err) => {
+        console.error('[MCP] Failed to start:', err);
+    });
+    server.listen(port, () => {
+        console.log(`OpenWriter running at http://localhost:${port}`);
+    });
+    // Open browser unless --no-open or running as MCP stdio pipe
+    const isMcpStdio = !process.stdout.isTTY;
+    if (!options.noOpen && !isMcpStdio) {
+        const open = await import('open');
+        const url = existsSync(clientDir)
+            ? `http://localhost:${port}`
+            : 'http://localhost:5173';
+        open.default(url).catch(() => { });
+    }
+}

package/dist/server/link-routes.js

@@ -0,0 +1,116 @@
+/**
+ * Express routes for document linking: create-link-doc and auto-tag-link.
+ * Mounted in index.ts to keep the main file lean.
+ */
+import { Router } from 'express';
+import { existsSync, writeFileSync } from 'fs';
+import { listWorkspaces, getWorkspace, addDoc, addContainerToWorkspace, tagDoc } from './workspaces.js';
+import { collectAllFiles } from './workspace-tree.js';
+import { getActiveFilename } from './documents.js';
+import { filePathForTitle, ensureDataDir } from './helpers.js';
+import { tiptapToMarkdown } from './markdown.js';
+export function createLinkRouter(b) {
+    const router = Router();
+    // Create a new doc, link-ready, auto-organized into workspace "Linked" container
+    router.post('/api/create-link-doc', (req, res) => {
+        try {
+            const { title } = req.body;
+            if (!title?.trim()) {
+                res.status(400).json({ error: 'title is required' });
+                return;
+            }
+            // 1. Create the .md file without switching active document
+            ensureDataDir();
+            const filePath = filePathForTitle(title.trim());
+            const filename = filePath.split(/[/\\]/).pop();
+            if (existsSync(filePath)) {
+                res.status(409).json({ error: 'Document already exists', filename });
+                return;
+            }
+            const emptyDoc = { type: 'doc', content: [{ type: 'paragraph', content: [] }] };
+            const metadata = { title: title.trim() };
+            const markdown = tiptapToMarkdown(emptyDoc, title.trim(), metadata);
+            writeFileSync(filePath, markdown, 'utf-8');
+            // 2. Find workspaces containing the current (source) doc
+            const currentFilename = getActiveFilename();
+            const allWorkspaces = listWorkspaces();
+            for (const wsInfo of allWorkspaces) {
+                try {
+                    const ws = getWorkspace(wsInfo.filename);
+                    const wsFiles = collectAllFiles(ws.root);
+                    if (!wsFiles.includes(currentFilename))
+                        continue;
+                    // 3. Ensure "Linked" container exists (find or create at bottom)
+                    let linkedContainerId = null;
+                    for (const node of ws.root) {
+                        if (node.type === 'container' && node.name === 'Linked') {
+                            linkedContainerId = node.id;
+                            break;
+                        }
+                    }
+                    if (!linkedContainerId) {
+                        const result = addContainerToWorkspace(wsInfo.filename, null, 'Linked');
+                        linkedContainerId = result.containerId;
+                    }
+                    // 4. Add new doc to "Linked" container
+                    try {
+                        addDoc(wsInfo.filename, linkedContainerId, filename, title.trim());
+                    }
+                    catch {
+                        // Doc may already be in workspace (e.g., duplicate call)
+                    }
+                    // 5. Tag with "linked"
+                    try {
+                        tagDoc(wsInfo.filename, filename, 'linked');
+                    }
+                    catch {
+                        // Doc not in workspace or already tagged
+                    }
+                }
+                catch {
+                    // Skip problematic workspaces
+                }
+            }
+            b.broadcastDocumentsChanged();
+            b.broadcastWorkspacesChanged();
+            res.json({ filename, title: title.trim() });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // Auto-tag an existing doc with "linked" in shared workspaces
+    router.post('/api/auto-tag-link', (req, res) => {
+        try {
+            const { targetFile } = req.body;
+            if (!targetFile) {
+                res.status(400).json({ error: 'targetFile is required' });
+                return;
+            }
+            const currentFilename = getActiveFilename();
+            const allWorkspaces = listWorkspaces();
+            let tagged = false;
+            for (const wsInfo of allWorkspaces) {
+                try {
+                    const ws = getWorkspace(wsInfo.filename);
+                    const wsFiles = collectAllFiles(ws.root);
+                    // Both source and target must be in same workspace
+                    if (!wsFiles.includes(currentFilename) || !wsFiles.includes(targetFile))
+                        continue;
+                    tagDoc(wsInfo.filename, targetFile, 'linked');
+                    tagged = true;
+                }
+                catch {
+                    // Skip
+                }
+            }
+            if (tagged)
+                b.broadcastWorkspacesChanged();
+            res.json({ success: true, tagged });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    return router;
+}