openwriter 0.14.0 → 0.16.0

package/dist/plugins/x-api/dist/index.js

@@ -0,0 +1,240 @@
+/**
+ * X API plugin for OpenWriter.
+ * Registers routes for checking X connection status and posting tweets.
+ * Uses @xdevplatform/xdk with OAuth1 credentials from plugin config.
+ */
+import { Client, OAuth1 } from '@xdevplatform/xdk';
+import { join, extname } from 'path';
+import { readFileSync, existsSync } from 'fs';
+import sharp from 'sharp';
+import twitter from 'twitter-text';
+const { parseTweet } = twitter;
+function createXClient(config) {
+    const apiKey = config['api-key'] || process.env.X_API_KEY || '';
+    const apiSecret = config['api-secret'] || process.env.X_API_SECRET || '';
+    const accessToken = config['access-token'] || process.env.X_ACCESS_TOKEN || '';
+    const accessTokenSecret = config['access-token-secret'] || process.env.X_ACCESS_TOKEN_SECRET || '';
+    if (!apiKey || !apiSecret || !accessToken || !accessTokenSecret)
+        return null;
+    const oauth1 = new OAuth1({
+        apiKey,
+        apiSecret,
+        callback: 'oob',
+        accessToken,
+        accessTokenSecret,
+    });
+    return new Client({ oauth1 });
+}
+const plugin = {
+    name: '@openwriter/plugin-x-api',
+    version: '0.1.0',
+    description: 'Post tweets from OpenWriter',
+    category: 'social-media',
+    configSchema: {
+        'api-key': { type: 'string', env: 'X_API_KEY', description: 'X API Key' },
+        'api-secret': { type: 'string', env: 'X_API_SECRET', description: 'X API Secret' },
+        'access-token': { type: 'string', env: 'X_ACCESS_TOKEN', description: 'X Access Token' },
+        'access-token-secret': { type: 'string', env: 'X_ACCESS_TOKEN_SECRET', description: 'X Access Token Secret' },
+    },
+    registerRoutes(ctx) {
+        // GET /api/x/status — check if plugin is configured + authenticated
+        ctx.app.get('/api/x/status', async (_req, res) => {
+            try {
+                const client = createXClient(ctx.config);
+                if (!client) {
+                    res.json({ connected: false });
+                    return;
+                }
+                const me = await client.users.getMe();
+                const username = me?.data?.username;
+                res.json({ connected: true, username: username || undefined });
+            }
+            catch (err) {
+                console.error('[X Plugin] Status check failed:', err.message);
+                res.json({ connected: false, error: err.message });
+            }
+        });
+        // POST /api/x/post — post a tweet (with optional media)
+        ctx.app.post('/api/x/post', async (req, res) => {
+            try {
+                const { text, replyTo, quoteTweetId, mediaIds } = req.body;
+                if ((!text || typeof text !== 'string') && (!Array.isArray(mediaIds) || mediaIds.length === 0)) {
+                    res.status(400).json({ success: false, error: 'text or mediaIds is required' });
+                    return;
+                }
+                if (mediaIds && (!Array.isArray(mediaIds) || mediaIds.length > 4)) {
+                    res.status(400).json({ success: false, error: 'mediaIds must be an array of 1-4 IDs' });
+                    return;
+                }
+                const client = createXClient(ctx.config);
+                if (!client) {
+                    res.status(400).json({ success: false, error: 'X API credentials not configured' });
+                    return;
+                }
+                const body = {};
+                if (text)
+                    body.text = text;
+                if (replyTo) {
+                    body.reply = { inReplyToTweetId: replyTo };
+                }
+                if (quoteTweetId) {
+                    body.quoteTweetId = quoteTweetId;
+                }
+                if (mediaIds && mediaIds.length > 0) {
+                    body.media = { media_ids: mediaIds };
+                }
+                const result = await client.posts.create(body);
+                const tweetId = result?.data?.id;
+                const tweetUrl = tweetId ? `https://x.com/i/status/${tweetId}` : undefined;
+                res.json({ success: true, tweetId, tweetUrl });
+            }
+            catch (err) {
+                const detail = err.data ? JSON.stringify(err.data) : err.message;
+                console.error('[X Plugin] Post failed:', detail);
+                res.status(500).json({ success: false, error: detail });
+            }
+        });
+        // POST /api/x/post-thread — post a full thread as a reply chain (with optional media per tweet)
+        ctx.app.post('/api/x/post-thread', async (req, res) => {
+            try {
+                const { tweets, replyTo } = req.body;
+                if (!Array.isArray(tweets) || tweets.length === 0) {
+                    res.status(400).json({ success: false, error: 'tweets must be a non-empty array' });
+                    return;
+                }
+                // Normalize: accept string[] or { text, mediaIds? }[]
+                const normalized = tweets.map((t) => typeof t === 'string' ? { text: t, mediaIds: undefined } : t);
+                // Validate character limits using X's weighted counting (emojis=2, URLs=23, CJK=2)
+                const CHAR_LIMIT = 25000;
+                const overLimit = normalized.map((t, i) => ({ i, len: parseTweet(t.text).weightedLength })).filter(x => x.len > CHAR_LIMIT);
+                if (overLimit.length > 0) {
+                    res.status(400).json({
+                        success: false,
+                        error: `${overLimit.length} tweet(s) exceed ${CHAR_LIMIT} chars: ${overLimit.map(x => `#${x.i + 1} (${x.len})`).join(', ')}`,
+                    });
+                    return;
+                }
+                // Validate mediaIds per tweet
+                for (let i = 0; i < normalized.length; i++) {
+                    const ids = normalized[i].mediaIds;
+                    if (ids && (!Array.isArray(ids) || ids.length > 4)) {
+                        res.status(400).json({ success: false, error: `Tweet ${i + 1}: mediaIds must be an array of 1-4 IDs` });
+                        return;
+                    }
+                }
+                const client = createXClient(ctx.config);
+                if (!client) {
+                    res.status(400).json({ success: false, error: 'X API credentials not configured' });
+                    return;
+                }
+                const postedTweets = [];
+                let previousTweetId = replyTo;
+                for (let i = 0; i < normalized.length; i++) {
+                    const { text, mediaIds } = normalized[i];
+                    const body = {};
+                    if (text)
+                        body.text = text;
+                    if (previousTweetId) {
+                        body.reply = { inReplyToTweetId: previousTweetId };
+                    }
+                    if (mediaIds && mediaIds.length > 0) {
+                        body.media = { media_ids: mediaIds };
+                    }
+                    const result = await client.posts.create(body);
+                    const tweetId = result?.data?.id;
+                    if (!tweetId) {
+                        res.status(500).json({
+                            success: false,
+                            postedTweets,
+                            failedAt: i,
+                            error: `Tweet ${i + 1} posted but no ID returned`,
+                        });
+                        return;
+                    }
+                    postedTweets.push({ index: i, tweetId, text });
+                    previousTweetId = tweetId;
+                }
+                // Build thread URL from first tweet
+                const firstTweetId = postedTweets[0]?.tweetId;
+                const threadUrl = firstTweetId ? `https://x.com/i/status/${firstTweetId}` : undefined;
+                console.log(`[X Plugin] Thread posted: ${postedTweets.length} tweets, ${threadUrl}`);
+                res.json({ success: true, postedTweets, threadUrl });
+            }
+            catch (err) {
+                console.error('[X Plugin] Post thread failed:', err.message);
+                res.status(500).json({ success: false, error: err.message });
+            }
+        });
+        // POST /api/x/upload-media — upload a local /_images/ file for tweet attachment
+        ctx.app.post('/api/x/upload-media', async (req, res) => {
+            try {
+                const { src } = req.body;
+                if (!src || typeof src !== 'string') {
+                    res.status(400).json({ success: false, error: 'src is required' });
+                    return;
+                }
+                // Security: only allow /_images/ paths, no traversal
+                if (!/^\/_images\/[^/\\]+$/.test(src)) {
+                    res.status(400).json({ success: false, error: 'Invalid image path — must be /_images/<filename>' });
+                    return;
+                }
+                const filename = src.replace('/_images/', '');
+                const filePath = join(ctx.dataDir, '_images', filename);
+                if (!existsSync(filePath)) {
+                    res.status(404).json({ success: false, error: `Image not found: ${filename}` });
+                    return;
+                }
+                const ext = extname(filename).toLowerCase();
+                const mimeMap = {
+                    '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+                    '.png': 'image/png', '.webp': 'image/webp',
+                    '.gif': 'image/jpeg', '.bmp': 'image/bmp',
+                    '.tiff': 'image/tiff', '.tif': 'image/tiff',
+                };
+                const mediaType = mimeMap[ext] || 'image/jpeg';
+                const client = createXClient(ctx.config);
+                if (!client) {
+                    res.status(400).json({ success: false, error: 'X API credentials not configured' });
+                    return;
+                }
+                let fileBuffer = readFileSync(filePath);
+                let uploadType = mediaType;
+                const origSize = fileBuffer.length;
+                // Compress large images or PNGs to JPEG to stay under X API limits
+                if (fileBuffer.length > 3 * 1024 * 1024 || ext === '.png') {
+                    fileBuffer = Buffer.from(await sharp(fileBuffer).jpeg({ quality: 85 }).toBuffer());
+                    uploadType = 'image/jpeg';
+                    console.log(`[X Plugin] Compressed ${filename}: ${(origSize / 1024 / 1024).toFixed(2)}MB → ${(fileBuffer.length / 1024 / 1024).toFixed(2)}MB`);
+                }
+                console.log(`[X Plugin] Uploading ${filename}: ${(fileBuffer.length / 1024 / 1024).toFixed(2)}MB, type: ${uploadType}`);
+                const mediaBase64 = fileBuffer.toString('base64');
+                const uploadResult = await client.media.upload({
+                    body: { media: mediaBase64, mediaCategory: 'tweet_image', mediaType: uploadType },
+                });
+                const mediaId = uploadResult?.data?.id
+                    || uploadResult?.media_id_string;
+                if (!mediaId) {
+                    res.status(500).json({ success: false, error: 'Upload succeeded but no media ID returned' });
+                    return;
+                }
+                console.log(`[X Plugin] Media uploaded: ${filename} → ${mediaId}`);
+                res.json({ success: true, mediaId });
+            }
+            catch (err) {
+                console.error('[X Plugin] Media upload failed:', err.message);
+                if (err.response) {
+                    try {
+                        const body = await err.response.text();
+                        console.error('[X Plugin] X API response:', err.response.status, body);
+                    }
+                    catch { /* ignore */ }
+                }
+                if (err.data)
+                    console.error('[X Plugin] Error data:', JSON.stringify(err.data));
+                console.error('[X Plugin] Full error:', JSON.stringify(err, Object.getOwnPropertyNames(err)));
+                res.status(500).json({ success: false, error: err.message });
+            }
+        });
+    },
+};
+export default plugin;

package/dist/plugins/x-api/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@openwriter/plugin-x-api",
+  "version": "0.1.0",
+  "description": "Post tweets from OpenWriter",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {
+    "@xdevplatform/xdk": "^0.4.0",
+    "twitter-text": "^3.1.0"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.0",
+    "typescript": "^5.6.0"
+  },
+  "openwriter": {
+    "displayName": "X / Twitter",
+    "category": "social-media"
+  },
+  "files": [
+    "dist/",
+    "package.json"
+  ]
+}

package/dist/server/comments.js

@@ -0,0 +1,256 @@
+/**
+ * Comments: sidecar JSON storage for inline user feedback (formerly "agent marks").
+ * Each document gets a sidecar file at DATA_DIR/_marks/{filename}.json.
+ * Storage directory name `_marks/` is retained for backwards compatibility with
+ * existing user data; the public vocabulary is "comment" everywhere else.
+ */
+import { join } from 'path';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, unlinkSync, renameSync } from 'fs';
+import { randomUUID } from 'crypto';
+import { getDataDir, ensureDataDir } from './helpers.js';
+function isResolved(c) {
+    return typeof c.resolvedAt === 'string' && c.resolvedAt.length > 0;
+}
+function getCommentsDir() { return join(getDataDir(), '_marks'); }
+function ensureCommentsDir() {
+    ensureDataDir();
+    if (!existsSync(getCommentsDir()))
+        mkdirSync(getCommentsDir(), { recursive: true });
+}
+function commentFilePath(filename) {
+    const safe = filename.replace(/[/\\]/g, '_');
+    return join(getCommentsDir(), `${safe}.json`);
+}
+function readCommentFile(filename) {
+    const path = commentFilePath(filename);
+    if (!existsSync(path))
+        return { marks: [] };
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return { marks: [] };
+    }
+}
+function writeCommentFile(filename, data) {
+    ensureCommentsDir();
+    const path = commentFilePath(filename);
+    if (data.marks.length === 0) {
+        if (existsSync(path))
+            unlinkSync(path);
+        return;
+    }
+    writeFileSync(path, JSON.stringify(data, null, 2));
+}
+export function addComment(filename, text, note, nodeId, nodeIds) {
+    const data = readCommentFile(filename);
+    const comment = {
+        id: randomUUID().slice(0, 8),
+        text,
+        note,
+        nodeId,
+        ...(nodeIds && nodeIds.length > 1 ? { nodeIds } : {}),
+        createdAt: new Date().toISOString(),
+    };
+    data.marks.push(comment);
+    writeCommentFile(filename, data);
+    return comment;
+}
+export function getComments(filename, opts = {}) {
+    const keep = (list) => opts.includeResolved ? list : list.filter((c) => !isResolved(c));
+    if (filename) {
+        const data = readCommentFile(filename);
+        const list = keep(data.marks);
+        if (list.length === 0)
+            return {};
+        return { [filename]: list };
+    }
+    ensureCommentsDir();
+    const result = {};
+    try {
+        const files = readdirSync(getCommentsDir());
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            const docFilename = file.replace(/\.json$/, '').replace(/_/g, ' ');
+            const path = join(getCommentsDir(), file);
+            try {
+                const data = JSON.parse(readFileSync(path, 'utf-8'));
+                const list = keep(data.marks);
+                if (list.length > 0)
+                    result[docFilename] = list;
+            }
+            catch { /* skip corrupt files */ }
+        }
+    }
+    catch { /* dir doesn't exist yet */ }
+    return result;
+}
+export function getCommentCount(filename) {
+    return readCommentFile(filename).marks.filter((c) => !isResolved(c)).length;
+}
+/** Count unresolved comments across all documents, optionally excluding one filename. */
+export function getGlobalCommentSummary(excludeFilename) {
+    ensureCommentsDir();
+    let totalComments = 0;
+    let docCount = 0;
+    try {
+        const files = readdirSync(getCommentsDir());
+        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(getCommentsDir(), file);
+            try {
+                const data = JSON.parse(readFileSync(path, 'utf-8'));
+                const unresolved = data.marks.filter((c) => !isResolved(c));
+                if (unresolved.length > 0) {
+                    totalComments += unresolved.length;
+                    docCount++;
+                }
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch { /* dir doesn't exist */ }
+    return { totalComments, docCount };
+}
+export function editComment(filename, id, note) {
+    const data = readCommentFile(filename);
+    const comment = data.marks.find((m) => m.id === id);
+    if (!comment)
+        return null;
+    comment.note = note;
+    writeCommentFile(filename, data);
+    return comment;
+}
+/** Mark comments as resolved (state change, NOT deletion). The records stay
+ *  on disk but get filtered out of normal `getComments` listings — so the
+ *  decoration disappears in the browser without losing the history. */
+export function resolveComments(ids) {
+    const idSet = new Set(ids);
+    const resolved = [];
+    const now = new Date().toISOString();
+    ensureCommentsDir();
+    try {
+        const files = readdirSync(getCommentsDir());
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            const filePath = join(getCommentsDir(), file);
+            try {
+                const data = JSON.parse(readFileSync(filePath, 'utf-8'));
+                let changed = false;
+                for (const c of data.marks) {
+                    if (idSet.has(c.id) && !isResolved(c)) {
+                        c.resolvedAt = now;
+                        resolved.push(c.id);
+                        changed = true;
+                    }
+                }
+                if (changed) {
+                    const docFilename = file.replace(/\.json$/, '').replace(/_/g, ' ');
+                    writeCommentFile(docFilename, data);
+                }
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch { /* dir doesn't exist */ }
+    return resolved;
+}
+/** Clear the resolved state on comments. Inverse of resolveComments. */
+export function unresolveComments(ids) {
+    const idSet = new Set(ids);
+    const cleared = [];
+    ensureCommentsDir();
+    try {
+        const files = readdirSync(getCommentsDir());
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            const filePath = join(getCommentsDir(), file);
+            try {
+                const data = JSON.parse(readFileSync(filePath, 'utf-8'));
+                let changed = false;
+                for (const c of data.marks) {
+                    if (idSet.has(c.id) && isResolved(c)) {
+                        delete c.resolvedAt;
+                        cleared.push(c.id);
+                        changed = true;
+                    }
+                }
+                if (changed) {
+                    const docFilename = file.replace(/\.json$/, '').replace(/_/g, ' ');
+                    writeCommentFile(docFilename, data);
+                }
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch { /* dir doesn't exist */ }
+    return cleared;
+}
+/** Permanently remove comments from the sidecar. Distinct from resolveComments —
+ *  resolve is a state change ("addressed, archive it"), delete is the destructive
+ *  "this record never should have existed" path. */
+export function deleteComments(ids) {
+    const idSet = new Set(ids);
+    const deleted = [];
+    ensureCommentsDir();
+    try {
+        const files = readdirSync(getCommentsDir());
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            const filePath = join(getCommentsDir(), 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)) {
+                        deleted.push(m.id);
+                        return false;
+                    }
+                    return true;
+                });
+                if (data.marks.length !== before) {
+                    const docFilename = file.replace(/\.json$/, '').replace(/_/g, ' ');
+                    writeCommentFile(docFilename, data);
+                }
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch { /* dir doesn't exist */ }
+    return deleted;
+}
+export function pruneStaleComments(filename, validNodeIds) {
+    const data = readCommentFile(filename);
+    if (data.marks.length === 0)
+        return 0;
+    const validSet = new Set(validNodeIds);
+    const before = data.marks.length;
+    data.marks = data.marks.filter((m) => {
+        if (m.nodeIds && m.nodeIds.length > 0) {
+            return m.nodeIds.some((id) => validSet.has(id));
+        }
+        return validSet.has(m.nodeId);
+    });
+    const pruned = before - data.marks.length;
+    if (pruned > 0)
+        writeCommentFile(filename, data);
+    return pruned;
+}
+/** Rename a comment sidecar file when a document is renamed. */
+export function renameComments(oldFilename, newFilename) {
+    const oldPath = commentFilePath(oldFilename);
+    if (!existsSync(oldPath))
+        return;
+    const newPath = commentFilePath(newFilename);
+    renameSync(oldPath, newPath);
+}