openwriter 0.6.3 → 0.6.5

package/dist/plugins/image-gen/dist/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Image Generation plugin for OpenWriter.
+ * Right-click an empty paragraph → "Generate image" → AI creates an image inline.
+ * Uses Google Gemini (Nano Banana 2) for generation, saves to /_images/.
+ */
+import type { Express } from 'express';
+interface PluginConfigField {
+    type: 'string' | 'number' | 'boolean';
+    required?: boolean;
+    env?: string;
+    description?: string;
+}
+interface PluginRouteContext {
+    app: Express;
+    config: Record<string, string>;
+    dataDir: string;
+}
+interface PluginContextMenuItem {
+    label: string;
+    shortcut?: string;
+    action: string;
+    condition?: 'has-selection' | 'empty-node' | 'always';
+    promptForInput?: boolean;
+}
+interface OpenWriterPlugin {
+    name: string;
+    version: string;
+    description?: string;
+    category?: 'writing' | 'social-media' | 'image-generation';
+    configSchema?: Record<string, PluginConfigField>;
+    registerRoutes?(ctx: PluginRouteContext): void | Promise<void>;
+    contextMenuItems?(): PluginContextMenuItem[];
+}
+declare const plugin: OpenWriterPlugin;
+export default plugin;

package/dist/plugins/image-gen/dist/index.js

@@ -0,0 +1,88 @@
+/**
+ * Image Generation plugin for OpenWriter.
+ * Right-click an empty paragraph → "Generate image" → AI creates an image inline.
+ * Uses Google Gemini (Nano Banana 2) for generation, saves to /_images/.
+ */
+import { join } from 'path';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { randomUUID } from 'crypto';
+const plugin = {
+    name: '@openwriter/plugin-image-gen',
+    version: '0.1.0',
+    description: 'Generate images with AI — right-click empty paragraphs',
+    category: 'image-generation',
+    configSchema: {
+        'gemini-api-key': {
+            type: 'string',
+            env: 'GEMINI_API_KEY',
+            required: true,
+            description: 'Google Gemini API key for image generation',
+        },
+    },
+    registerRoutes(ctx) {
+        ctx.app.post('/api/image-gen/generate', async (req, res) => {
+            try {
+                const { prompt } = req.body;
+                if (!prompt || typeof prompt !== 'string') {
+                    res.status(400).json({ success: false, error: 'prompt is required' });
+                    return;
+                }
+                if (prompt.length > 1000) {
+                    res.status(400).json({ success: false, error: 'prompt must be under 1000 characters' });
+                    return;
+                }
+                const apiKey = ctx.config['gemini-api-key'] || process.env.GEMINI_API_KEY || '';
+                if (!apiKey) {
+                    res.status(400).json({ success: false, error: 'GEMINI_API_KEY not configured' });
+                    return;
+                }
+                // Dynamic import — @google/genai is ESM
+                const { GoogleGenAI } = await import('@google/genai');
+                const ai = new GoogleGenAI({ apiKey });
+                console.log(`[ImageGen] Generating image: "${prompt.slice(0, 80)}..."`);
+                const response = await ai.models.generateContent({
+                    model: 'gemini-3.1-flash-image-preview',
+                    contents: `Generate a 16:9 aspect ratio image: ${prompt}`,
+                    config: {
+                        responseModalities: ['IMAGE'],
+                    },
+                });
+                const parts = response.candidates?.[0]?.content?.parts;
+                if (!parts || parts.length === 0) {
+                    res.status(422).json({ success: false, error: 'No image generated — content may have been filtered' });
+                    return;
+                }
+                const imagePart = parts.find((p) => p.inlineData);
+                const imageBytes = imagePart?.inlineData?.data;
+                if (!imageBytes) {
+                    res.status(422).json({ success: false, error: 'No image data in response' });
+                    return;
+                }
+                // Save to dataDir/_images/
+                const imagesDir = join(ctx.dataDir, '_images');
+                if (!existsSync(imagesDir))
+                    mkdirSync(imagesDir, { recursive: true });
+                const filename = `${randomUUID().slice(0, 8)}.png`;
+                const filepath = join(imagesDir, filename);
+                writeFileSync(filepath, Buffer.from(imageBytes, 'base64'));
+                console.log(`[ImageGen] Saved: ${filepath}`);
+                res.json({ success: true, src: `/_images/${filename}` });
+            }
+            catch (err) {
+                console.error('[ImageGen] Generation failed:', err?.message || err);
+                res.status(500).json({ success: false, error: err?.message || 'Image generation failed' });
+            }
+        });
+    },
+    contextMenuItems() {
+        return [
+            {
+                label: 'Generate image',
+                action: 'img:generate',
+                condition: 'always',
+                promptForInput: true,
+            },
+        ];
+    },
+};
+export default plugin;

package/dist/plugins/image-gen/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@openwriter/plugin-image-gen",
+  "version": "0.1.0",
+  "description": "Generate images with AI — right-click empty paragraphs",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {
+    "@google/genai": "^1.42.0"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.0",
+    "typescript": "^5.6.0"
+  },
+  "openwriter": {
+    "displayName": "Image Generator",
+    "category": "image-generation"
+  },
+  "files": [
+    "dist/",
+    "package.json"
+  ]
+}

package/dist/plugins/publish/dist/helpers.d.ts

@@ -0,0 +1,54 @@
+import MarkdownIt from 'markdown-it';
+export interface ServerModules {
+    tiptapToMarkdown: (doc: any, title: string, metadata?: Record<string, any>) => string;
+    getDocument: () => any;
+    getTitle: () => string;
+    getMetadata: () => Record<string, any>;
+    getActiveProfile: () => string;
+    getDataDir: () => string;
+    getDocId: () => string;
+    platformFetch: (path: string, options?: RequestInit) => Promise<Response>;
+}
+export declare function getServerModules(): Promise<ServerModules>;
+export interface PluginConfigField {
+    type: 'string' | 'number' | 'boolean';
+    required?: boolean;
+    env?: string;
+    description?: string;
+}
+export interface PluginMcpTool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    handler: (params: Record<string, unknown>) => Promise<unknown>;
+}
+export interface OpenWriterPlugin {
+    name: string;
+    version: string;
+    description?: string;
+    category?: 'writing' | 'social-media' | 'image-generation' | 'publishing' | 'productivity' | 'analytics';
+    configSchema?: Record<string, PluginConfigField>;
+    mcpTools?(config: Record<string, string>): PluginMcpTool[];
+}
+export declare const md: MarkdownIt;
+/** Strip YAML frontmatter and TipTap empty markers from markdown output */
+export declare function stripFrontmatter(markdown: string): string;
+/** Scan HTML for /_images/ references, read local files, return base64 array for R2 upload */
+export declare function extractLocalImages(html: string): Promise<Array<{
+    path: string;
+    data: string;
+    content_type: string;
+}>>;
+/** Convert current document's TipTap JSON to body HTML + plain text */
+export declare function documentToEmail(): Promise<{
+    html: string;
+    text: string;
+    subject: string;
+    json: any;
+}>;
+/** Strip markdown syntax to produce clean plain text for email */
+export declare function markdownToPlainText(markdown: string): string;
+/** Strip inline markdown marks from a string */
+export declare function stripInline(text: string): string;
+/** Make an authenticated request to the Publish API via platform proxy */
+export declare function publishFetch(_config: Record<string, string>, path: string, options?: RequestInit): Promise<Response>;

package/dist/plugins/publish/dist/helpers.js

@@ -0,0 +1,185 @@
+import MarkdownIt from 'markdown-it';
+import markdownItIns from 'markdown-it-ins';
+import markdownItMark from 'markdown-it-mark';
+import markdownItSub from 'markdown-it-sub';
+import markdownItSup from 'markdown-it-sup';
+import { readFileSync, existsSync } from 'fs';
+import { join, extname } from 'path';
+// Lazy-load server modules at runtime (same process, resolved from monorepo root)
+const baseDir = new URL('../../../packages/openwriter/dist/server/', import.meta.url).href;
+let _cached = null;
+export async function getServerModules() {
+    if (_cached)
+        return _cached;
+    const [markdown, state, helpers, connections] = await Promise.all([
+        import(baseDir + 'markdown.js'),
+        import(baseDir + 'state.js'),
+        import(baseDir + 'helpers.js'),
+        import(baseDir + 'connections.js'),
+    ]);
+    _cached = {
+        tiptapToMarkdown: markdown.tiptapToMarkdown,
+        getDocument: state.getDocument,
+        getTitle: state.getTitle,
+        getMetadata: state.getMetadata,
+        getActiveProfile: helpers.getActiveProfile,
+        getDataDir: helpers.getDataDir,
+        getDocId: state.getDocId,
+        platformFetch: connections.platformFetch,
+    };
+    return _cached;
+}
+// markdown-it instance matching export-routes.ts configuration
+export const md = new MarkdownIt({ linkify: false, html: true });
+md.enable('strikethrough');
+md.use(markdownItIns);
+md.use(markdownItMark);
+md.use(markdownItSub);
+md.use(markdownItSup);
+/** Strip YAML frontmatter and TipTap empty markers from markdown output */
+export function stripFrontmatter(markdown) {
+    let result = markdown;
+    const fmMatch = result.match(/^---\n[\s\S]*?\n---\n\n/);
+    if (fmMatch)
+        result = result.slice(fmMatch[0].length);
+    result = result.replace(/^\s*<!--\s*-->\s*$/gm, '');
+    return result.trim();
+}
+/** Scan HTML for /_images/ references, read local files, return base64 array for R2 upload */
+export async function extractLocalImages(html) {
+    const server = await getServerModules();
+    const dataDir = server.getDataDir();
+    const images = [];
+    const regex = /\/_images\/[^\s"'<>]+/g;
+    const seen = new Set();
+    let match;
+    while ((match = regex.exec(html)) !== null) {
+        const imgPath = match[0];
+        if (seen.has(imgPath))
+            continue;
+        seen.add(imgPath);
+        const localFile = join(dataDir, imgPath);
+        if (!existsSync(localFile))
+            continue;
+        const data = readFileSync(localFile).toString('base64');
+        const ext = extname(imgPath).toLowerCase();
+        const mimeMap = {
+            '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+            '.png': 'image/png', '.gif': 'image/gif',
+            '.webp': 'image/webp', '.svg': 'image/svg+xml',
+        };
+        images.push({ path: imgPath, data, content_type: mimeMap[ext] || 'image/png' });
+    }
+    return images;
+}
+/** Convert current document's TipTap JSON to body HTML + plain text */
+export async function documentToEmail() {
+    const server = await getServerModules();
+    const doc = server.getDocument();
+    const title = server.getTitle();
+    const metadata = server.getMetadata();
+    const raw = server.tiptapToMarkdown(doc, title, metadata);
+    const clean = stripFrontmatter(raw).trim();
+    const html = md.render(clean);
+    const text = markdownToPlainText(clean);
+    return { html, text, subject: title, json: doc };
+}
+/** Strip markdown syntax to produce clean plain text for email */
+export function markdownToPlainText(markdown) {
+    const lines = markdown.split('\n');
+    const out = [];
+    let inCodeBlock = false;
+    let codeLines = [];
+    for (const line of lines) {
+        if (/^```/.test(line)) {
+            if (inCodeBlock) {
+                for (const cl of codeLines)
+                    out.push('    ' + cl);
+                codeLines = [];
+                inCodeBlock = false;
+            }
+            else {
+                inCodeBlock = true;
+            }
+            continue;
+        }
+        if (inCodeBlock) {
+            codeLines.push(line);
+            continue;
+        }
+        if (/^\s*<!--.*-->\s*$/.test(line))
+            continue;
+        if (/^!\[.*\]\(.*\)\s*$/.test(line))
+            continue;
+        if (/^\|[\s:|-]+\|\s*$/.test(line))
+            continue;
+        if (/^\|(.+)\|\s*$/.test(line)) {
+            const cells = line
+                .slice(1, -1)
+                .split('|')
+                .map((c) => stripInline(c.trim()));
+            out.push(cells.join(' | '));
+            continue;
+        }
+        if (/^[-*_]{3,}\s*$/.test(line)) {
+            out.push('---');
+            continue;
+        }
+        const headerMatch = line.match(/^(#{1,6})\s+(.*)/);
+        if (headerMatch) {
+            out.push(stripInline(headerMatch[2]));
+            continue;
+        }
+        const bqMatch = line.match(/^(>\s?)+(.*)$/);
+        if (bqMatch) {
+            out.push(stripInline(bqMatch[2]));
+            continue;
+        }
+        const taskMatch = line.match(/^(\s*)[-*+]\s+\[([ xX])\]\s+(.*)/);
+        if (taskMatch) {
+            const indent = taskMatch[1];
+            const check = taskMatch[2] === ' ' ? '[ ]' : '[x]';
+            out.push(indent + check + ' ' + stripInline(taskMatch[3]));
+            continue;
+        }
+        const ulMatch = line.match(/^(\s*)[-*+]\s+(.*)/);
+        if (ulMatch) {
+            out.push(ulMatch[1] + '- ' + stripInline(ulMatch[2]));
+            continue;
+        }
+        const olMatch = line.match(/^(\s*)(\d+)\.\s+(.*)/);
+        if (olMatch) {
+            out.push(olMatch[1] + olMatch[2] + '. ' + stripInline(olMatch[3]));
+            continue;
+        }
+        out.push(stripInline(line));
+    }
+    if (inCodeBlock) {
+        for (const cl of codeLines)
+            out.push('    ' + cl);
+    }
+    return out
+        .join('\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+/** Strip inline markdown marks from a string */
+export function stripInline(text) {
+    return text
+        .replace(/!\[([^\]]*)\]\([^)]+\)/g, '')
+        .replace(/\[([^\]]+)\]\(([^)]+)\)/g, '$1 ($2)')
+        .replace(/`([^`]+)`/g, '$1')
+        .replace(/(\*{3}|_{3})(.+?)\1/g, '$2')
+        .replace(/(\*{2}|_{2})(.+?)\1/g, '$2')
+        .replace(/(\*|_)(.+?)\1/g, '$2')
+        .replace(/~~(.+?)~~/g, '$1')
+        .replace(/\+\+(.+?)\+\+/g, '$1')
+        .replace(/==(.+?)==/g, '$1')
+        .replace(/~([^~]+)~/g, '$1')
+        .replace(/\^([^^]+)\^/g, '$1');
+}
+/** Make an authenticated request to the Publish API via platform proxy */
+export async function publishFetch(_config, path, options = {}) {
+    const server = await getServerModules();
+    return server.platformFetch(path, options);
+}

package/dist/plugins/publish/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { OpenWriterPlugin } from './helpers.js';
+declare const plugin: OpenWriterPlugin;
+export default plugin;