openwriter 0.40.1 → 0.40.2

package/dist/plugins/github/dist/index.js

@@ -0,0 +1,112 @@
+/**
+ * GitHub Plugin for OpenWriter.
+ * Provides two capabilities:
+ *   1. Docs backup sync — lifted from core. Auth: existing `gh auth`.
+ *   2. Blog sites (Phase 3+) — list of blog repos, post via local git ops.
+ *
+ * This phase ships capability 1 only. Routes match the previous core mount
+ * points exactly so SyncButton + SyncSetupModal continue to work unchanged.
+ */
+import { getServerModules } from './helpers.js';
+import { getSyncStatus, getCapabilities, getPendingFiles, setupWithGh, setupWithPat, connectExisting, pushSync, } from './git-sync.js';
+import { blogTools } from './blog-tools.js';
+const plugin = {
+    name: '@openwriter/plugin-github',
+    version: '0.1.0',
+    description: 'GitHub Plugin: Sync files and publish blogs.',
+    category: 'productivity',
+    // No user-input credentials — auth piggybacks on the user's existing
+    // `gh auth` (verified in getCapabilities). Blog-site list is stored
+    // outside the configSchema as structured data (Phase 3+).
+    configSchema: {},
+    mcpTools() {
+        return blogTools();
+    },
+    registerRoutes(ctx) {
+        const broadcast = async (status) => {
+            try {
+                const srv = await getServerModules();
+                srv.broadcastSyncStatus(status);
+            }
+            catch (err) {
+                console.error('[GitHub Plugin] broadcast failed:', err.message);
+            }
+        };
+        // MCP-15: log the real error server-side; return a generic message to the
+        // client so internal details (paths, git output, tokens) never leak.
+        const fail = (res, where, err, extra = {}) => {
+            console.error(`[GitHub Plugin] ${where} failed:`, err?.message || err);
+            res.status(500).json({ error: 'Internal error', ...extra });
+        };
+        ctx.app.get('/api/sync/status', async (_req, res) => {
+            try {
+                res.json(await getSyncStatus());
+            }
+            catch (err) {
+                fail(res, 'sync/status', err, { state: 'error' });
+            }
+        });
+        ctx.app.get('/api/sync/capabilities', async (_req, res) => {
+            try {
+                res.json(await getCapabilities());
+            }
+            catch (err) {
+                fail(res, 'sync/capabilities', err);
+            }
+        });
+        ctx.app.get('/api/sync/pending', async (_req, res) => {
+            try {
+                res.json(await getPendingFiles());
+            }
+            catch (err) {
+                fail(res, 'sync/pending', err);
+            }
+        });
+        ctx.app.post('/api/sync/setup', async (req, res) => {
+            try {
+                const { method, repoName, remoteUrl, pat, isPrivate } = req.body;
+                if (method === 'gh') {
+                    await setupWithGh(repoName || 'openwriter-docs', isPrivate !== false);
+                }
+                else if (method === 'pat') {
+                    if (!pat) {
+                        res.status(400).json({ error: 'PAT is required' });
+                        return;
+                    }
+                    await setupWithPat(pat, repoName || 'openwriter-docs', isPrivate !== false);
+                }
+                else if (method === 'connect') {
+                    if (!remoteUrl) {
+                        res.status(400).json({ error: 'Remote URL is required' });
+                        return;
+                    }
+                    await connectExisting(remoteUrl, pat);
+                }
+                else {
+                    res.status(400).json({ error: 'Invalid method. Use: gh, pat, or connect' });
+                    return;
+                }
+                const status = await getSyncStatus();
+                await broadcast(status);
+                res.json({ success: true, status });
+            }
+            catch (err) {
+                // Setup surfaces GitHub's own API feedback (e.g. "name already exists",
+                // "bad credentials") which is user-actionable; the remote is now
+                // credential-free so this carries no secret. Still log the full error.
+                console.error('[GitHub Plugin] sync/setup failed:', err?.message || err);
+                res.status(500).json({ error: err?.message || 'Setup failed' });
+            }
+        });
+        ctx.app.post('/api/sync/push', async (_req, res) => {
+            try {
+                const result = await pushSync((s) => { void broadcast(s); });
+                res.json(result);
+            }
+            catch (err) {
+                fail(res, 'sync/push', err, { state: 'error' });
+            }
+        });
+    },
+};
+export default plugin;

package/dist/plugins/github/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@openwriter/plugin-github",
+  "version": "0.1.0",
+  "description": "GitHub Plugin: Sync files and publish blogs.",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/express": "^5.0.0",
+    "typescript": "^5.6.0"
+  },
+  "openwriter": {
+    "displayName": "GitHub",
+    "category": "productivity"
+  },
+  "files": [
+    "dist/",
+    "package.json"
+  ]
+}

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,149 @@
+/**
+ * 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, readFileSync } from 'fs';
+import { randomUUID } from 'crypto';
+import { homedir } from 'os';
+/** Fallback: generate image via the publish platform API, download and save locally */
+async function generateViaPlatform(prompt, dataDir, imageApiKey, aspectRatio = '16:9') {
+    const configPath = join(homedir(), '.openwriter', 'config.json');
+    if (!existsSync(configPath))
+        return null;
+    const config = JSON.parse(readFileSync(configPath, 'utf8'));
+    const publishConfig = config.plugins?.['@openwriter/plugin-publish']?.config || {};
+    const platformKey = publishConfig['api-key'];
+    const apiUrl = publishConfig['api-url'] || 'https://publish.openwriter.io';
+    const profile = config.activeProfile || 'Default';
+    if (!platformKey)
+        return null;
+    console.log(`[ImageGen] Generating image (platform): "${prompt.slice(0, 80)}..."`);
+    const res = await fetch(`${apiUrl}/images/generate`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${platformKey}`,
+            'X-Profile': profile,
+            // BYO image key → worker skips the shared-key allotment and bills the user's own key (uncapped).
+            ...(imageApiKey ? { 'X-Image-Key': imageApiKey } : {}),
+        },
+        body: JSON.stringify({ prompt, aspect_ratio: aspectRatio }),
+    });
+    if (!res.ok) {
+        const err = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
+        throw new Error(err.error || 'Platform image generation failed');
+    }
+    const data = await res.json();
+    // Download image and save locally
+    const imageRes = await fetch(data.url);
+    const imageBuffer = Buffer.from(await imageRes.arrayBuffer());
+    const imagesDir = join(dataDir, '_images');
+    if (!existsSync(imagesDir))
+        mkdirSync(imagesDir, { recursive: true });
+    const filename = `${randomUUID().slice(0, 8)}.png`;
+    writeFileSync(join(imagesDir, filename), imageBuffer);
+    console.log(`[ImageGen] Saved (platform): ${join(imagesDir, filename)}`);
+    return { success: true, src: `/_images/${filename}` };
+}
+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: false,
+            description: 'Google Gemini API key for image generation (optional — falls back to publish platform)',
+        },
+        imageApiKey: {
+            type: 'string',
+            required: false,
+            description: "Your own image API key (Gemini) — unlimited generations at your cost. Leave blank to use OpenWriter's included allotment.",
+        },
+    },
+    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 || '';
+                let imageBytes;
+                if (apiKey) {
+                    // Local Gemini generation
+                    const { GoogleGenAI } = await import('@google/genai');
+                    const ai = new GoogleGenAI({ apiKey });
+                    console.log(`[ImageGen] Generating image (local): "${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);
+                    imageBytes = imagePart?.inlineData?.data;
+                    if (!imageBytes) {
+                        res.status(422).json({ success: false, error: 'No image data in response' });
+                        return;
+                    }
+                }
+                else {
+                    // Fallback: generate via publish platform API.
+                    // Pass the user's own image key (if set) so the worker bills it instead of the shared allotment.
+                    const platformResult = await generateViaPlatform(prompt, ctx.dataDir, ctx.config['imageApiKey']);
+                    if (!platformResult) {
+                        res.status(400).json({ success: false, error: 'No GEMINI_API_KEY and publish platform not configured. Set GEMINI_API_KEY or log in to the publish plugin.' });
+                        return;
+                    }
+                    // platformResult already saved to disk
+                    res.json(platformResult);
+                    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) {
+                const msg = err?.message || 'Image generation failed';
+                console.error('[ImageGen] Generation failed:', msg);
+                const friendly = /Unexpected token.*<!DOCTYPE/i.test(msg)
+                    ? 'Image generation failed — your Gemini API key may be invalid or expired. Check your GEMINI_API_KEY.'
+                    : msg;
+                res.status(500).json({ success: false, error: friendly });
+            }
+        });
+    },
+    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,66 @@
+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 PluginRouteContext {
+    app: import('express').Router;
+    config: Record<string, string>;
+    dataDir: string;
+}
+export interface PluginSidebarMenuItem {
+    label: string;
+    action: string;
+    promptForFocus?: boolean;
+}
+export interface OpenWriterPlugin {
+    name: string;
+    version: string;
+    description?: string;
+    category?: 'writing' | 'social-media' | 'image-generation' | 'publishing' | 'productivity' | 'analytics';
+    configSchema?: Record<string, PluginConfigField>;
+    registerRoutes?(ctx: PluginRouteContext): void | Promise<void>;
+    mcpTools?(config: Record<string, string>): PluginMcpTool[];
+    sidebarMenuItems?(): PluginSidebarMenuItem[];
+}
+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,199 @@
+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
+// npm package: dist/plugins/publish/dist/helpers.js → ../../../server/
+// Monorepo:    plugins/publish/dist/helpers.js → ../../../packages/openwriter/dist/server/
+const npmBase = new URL('../../../server/', import.meta.url).href;
+const monoBase = new URL('../../../packages/openwriter/dist/server/', import.meta.url).href;
+let _cached = null;
+async function tryImport(base) {
+    const [markdown, state, helpers, connections] = await Promise.all([
+        import(base + 'markdown.js'),
+        import(base + 'state.js'),
+        import(base + 'helpers.js'),
+        import(base + 'connections.js'),
+    ]);
+    return { markdown, state, helpers, connections };
+}
+export async function getServerModules() {
+    if (_cached)
+        return _cached;
+    // Try npm package layout first, fall back to monorepo layout
+    let markdown, state, helpers, connections;
+    try {
+        ({ markdown, state, helpers, connections } = await tryImport(npmBase));
+    }
+    catch {
+        ({ markdown, state, helpers, connections } = await tryImport(monoBase));
+    }
+    _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;