openwriter 0.2.1 → 0.3.0

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,8 +8,9 @@ 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';
+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 {
@@ -213,7 +230,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 +266,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 +294,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 +345,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 +362,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 +479,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() {
@@ -602,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'))
@@ -611,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;
     }
@@ -747,3 +790,175 @@ 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
+// ============================================================================
+/** 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/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;
+}