npm - openwriter - Versions diffs - 0.40.2 → 0.40.3 - Mend

openwriter 0.40.2 → 0.40.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/dist/client/assets/{index-Dxbv2n2m.js → index-BjaX2BWN.js} +49 -49
package/dist/client/index.html +1 -1
package/dist/server/blog-routes.js +160 -0
package/dist/server/documents.js +56 -9
package/dist/server/git-sync.js +273 -0
package/dist/server/marks.js +182 -0
package/dist/server/mcp.js +68 -18
package/dist/server/sync-routes.js +75 -0
package/package.json +1 -1
package/skill/SKILL.md +15 -7

package/dist/client/index.html CHANGED Viewed

@@ -10,7 +10,7 @@
     <!-- Fonts are self-hosted (bundled via @fontsource, imported in main.tsx →
          themes/vendored-fonts.css). No external font CDN: a local-first editor
          must work offline and behind content blockers. -->
-    <script type="module" crossorigin src="/assets/index-Dxbv2n2m.js"></script>
+    <script type="module" crossorigin src="/assets/index-BjaX2BWN.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-DiJrXBgV.css">
   </head>
   <body>

package/dist/server/blog-routes.js ADDED Viewed

@@ -0,0 +1,160 @@
+/**
+ * Blog publishing routes — push blog content to GitHub via platform connection.
+ * Builds clean YAML frontmatter + markdown body, collects images, posts to platform.
+ */
+import { Router } from 'express';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import matter from 'gray-matter';
+import { getDocument, getTitle, getMetadata, save, cancelDebouncedSave } from './state.js';
+import { tiptapToMarkdown } from './markdown.js';
+import { platformFetch, isAuthenticated } from './connections.js';
+import { getDataDir } from './helpers.js';
+export function createBlogRouter() {
+    const router = Router();
+    // Find active GitHub connection for blog publishing
+    router.get('/api/blog/connection', async (_req, res) => {
+        try {
+            if (!isAuthenticated()) {
+                res.json({ connection: null });
+                return;
+            }
+            const upstream = await platformFetch('/connections/unified');
+            if (!upstream.ok) {
+                res.json({ connection: null });
+                return;
+            }
+            const data = await upstream.json();
+            const ghConn = data.connections?.find((c) => c.provider === 'github' && c.status === 'active');
+            res.json({ connection: ghConn || null });
+        }
+        catch {
+            res.json({ connection: null });
+        }
+    });
+    // Publish blog post to GitHub via platform connection
+    router.post('/api/blog/publish', async (req, res) => {
+        try {
+            if (!isAuthenticated()) {
+                res.status(401).json({ error: 'Not authenticated' });
+                return;
+            }
+            // Flush current doc to disk
+            cancelDebouncedSave();
+            save();
+            const doc = getDocument();
+            const title = getTitle();
+            const metadata = getMetadata();
+            const blogCtx = metadata.blogContext;
+            if (!blogCtx?.active) {
+                res.status(400).json({ error: 'Not a blog document' });
+                return;
+            }
+            // Get clean markdown body (strip OpenWriter JSON frontmatter)
+            const fullMd = tiptapToMarkdown(doc, title, metadata);
+            const parsed = matter(fullMd);
+            let markdownBody = parsed.content.trim();
+            // Build clean blog YAML frontmatter — only include fields the target schema expects
+            const fm = {
+                title,
+                description: blogCtx.description || '',
+                date: blogCtx.date || new Date().toISOString().split('T')[0],
+            };
+            // Optional fields — only include if explicitly set
+            if (blogCtx.author)
+                fm.author = blogCtx.author;
+            if (blogCtx.layout)
+                fm.layout = blogCtx.layout;
+            if (blogCtx.category)
+                fm.category = blogCtx.category;
+            if (blogCtx.tags?.length)
+                fm.tags = blogCtx.tags;
+            if (blogCtx.draft)
+                fm.draft = true;
+            // Find GitHub connection
+            const connectionId = req.body.connectionId;
+            const connRes = await platformFetch('/connections/unified');
+            if (!connRes.ok) {
+                res.status(500).json({ error: 'Failed to fetch connections' });
+                return;
+            }
+            const connData = await connRes.json();
+            const ghConn = connectionId
+                ? connData.connections?.find((c) => c.id === connectionId)
+                : connData.connections?.find((c) => c.provider === 'github' && c.status === 'active');
+            if (!ghConn) {
+                res.status(400).json({ error: 'No GitHub connection found. Connect a GitHub repo first.' });
+                return;
+            }
+            // Fetch connection config to derive image web path
+            let imageWebPrefix = '/images';
+            try {
+                const cfgRes = await platformFetch(`/connections/${ghConn.id}/config`);
+                if (cfgRes.ok) {
+                    const cfg = await cfgRes.json();
+                    const imgDir = cfg.config?.imageDir || cfg.imageDir;
+                    if (imgDir) {
+                        imageWebPrefix = '/' + imgDir.replace(/^public\/?/, '');
+                    }
+                }
+            }
+            catch { /* fall back to /images */ }
+            // Cover image — read as base64 for GitHub commit
+            let imageBase64;
+            let imageFilename;
+            if (blogCtx.coverImage) {
+                const imgPath = blogCtx.coverImage.replace(/^\/_images\//, '');
+                const fullImgPath = join(getDataDir(), '_images', imgPath);
+                if (existsSync(fullImgPath)) {
+                    imageBase64 = readFileSync(fullImgPath).toString('base64');
+                    imageFilename = imgPath;
+                    fm.image = `${imageWebPrefix}/${imgPath}`;
+                }
+            }
+            // Collect inline images and rewrite paths in markdown
+            const inlineImages = [];
+            const imgRegex = /!\[([^\]]*)\]\(\/_images\/([^)]+)\)/g;
+            markdownBody = markdownBody.replace(imgRegex, (_match, alt, imgFile) => {
+                const fullImgPath = join(getDataDir(), '_images', imgFile);
+                if (existsSync(fullImgPath)) {
+                    inlineImages.push({ filename: imgFile, base64: readFileSync(fullImgPath).toString('base64') });
+                }
+                return `![${alt}](${imageWebPrefix}/${imgFile})`;
+            });
+            // Assemble full markdown with YAML frontmatter
+            const yamlLines = Object.entries(fm).map(([k, v]) => {
+                if (Array.isArray(v))
+                    return `${k}:\n${v.map(i => `  - ${JSON.stringify(i)}`).join('\n')}`;
+                if (typeof v === 'boolean')
+                    return `${k}: ${v}`;
+                return `${k}: ${JSON.stringify(v)}`;
+            });
+            const fullMarkdown = `---\n${yamlLines.join('\n')}\n---\n\n${markdownBody}`;
+            // Build target filename from slug or title
+            const slug = blogCtx.slug || title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+            const filename = `${slug}.md`;
+            // Post to platform — matches worker's expected payload:
+            // { markdown, filename, imageBase64?, imageFilename?, commitMessage? }
+            const upstream = await platformFetch(`/connections/${ghConn.id}/post`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    markdown: fullMarkdown,
+                    filename,
+                    ...(imageBase64 && imageFilename ? { imageBase64, imageFilename } : {}),
+                    ...(inlineImages.length ? { images: inlineImages } : {}),
+                    commitMessage: `Add blog post: ${title}`,
+                }),
+            });
+            const result = await upstream.json();
+            if (!upstream.ok) {
+                res.status(upstream.status).json(result);
+                return;
+            }
+            res.json({ success: true, ...result });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    return router;
+}

package/dist/server/documents.js CHANGED Viewed

@@ -913,6 +913,19 @@ export async function deleteDocument(filename) {
         throw new Error('Cannot delete the only document');
     }
     const isDeletingActive = targetPath === getFilePath();
+    // Capture the sidebar's flat order BEFORE the file is trashed, so a
+    // delete-of-the-active-doc can land the switch on the doc ADJACENT to the one
+    // removed (least-jarring — the view barely moves). The prior behavior switched
+    // to the globally newest-by-mtime doc, which flung the editor + filetree across
+    // the workspace to an unrelated doc. Only needed when deleting the active doc.
+    const orderedBefore = isDeletingActive
+        ? (() => { try {
+            return listDocuments().map((d) => d.filename);
+        }
+        catch {
+            return [];
+        } })()
+        : [];
     // Read docId BEFORE deleting the file so we can retire its overlay sidecar
     // in lockstep. The sidecar's lifecycle is bound to the docId's existence in
     // the workspace; delete retires the docId, archive does not.
@@ -933,16 +946,50 @@ export async function deleteDocument(filename) {
     if (docIdToRetire)
         deleteOverlay(docIdToRetire);
     if (isDeletingActive) {
-        const remaining = readdirSync(getDataDir())
-            .filter((f) => f.endsWith('.md'))
-            .map((f) => ({ name: f, path: join(getDataDir(), f), mtime: statSync(join(getDataDir(), f)).mtimeMs }))
-            .sort((a, b) => b.mtime - a.mtime);
-        if (remaining.length > 0) {
-            const next = remaining[0];
-            const raw = readFileSync(next.path, 'utf-8');
+        // Prefer the doc adjacent to the deleted one in sidebar order — previous
+        // sibling first, then next. Falls back to newest-by-mtime only if the order
+        // lookup comes up empty (e.g. manifest missing), preserving old behavior.
+        let nextName = null;
+        const idx = orderedBefore.indexOf(filename);
+        if (idx >= 0) {
+            for (let i = idx - 1; i >= 0; i--) {
+                if (orderedBefore[i] !== filename) {
+                    nextName = orderedBefore[i];
+                    break;
+                }
+            }
+            if (!nextName) {
+                for (let i = idx + 1; i < orderedBefore.length; i++) {
+                    if (orderedBefore[i] !== filename) {
+                        nextName = orderedBefore[i];
+                        break;
+                    }
+                }
+            }
+        }
+        let nextPath = null;
+        if (nextName) {
+            const p = resolveDocPath(nextName);
+            if (existsSync(p))
+                nextPath = p;
+        }
+        if (!nextPath) {
+            const remaining = readdirSync(getDataDir())
+                .filter((f) => f.endsWith('.md'))
+                .map((f) => ({ name: f, path: join(getDataDir(), f), mtime: statSync(join(getDataDir(), f)).mtimeMs }))
+                .sort((a, b) => b.mtime - a.mtime);
+            if (remaining.length > 0) {
+                nextName = remaining[0].name;
+                nextPath = remaining[0].path;
+            }
+        }
+        if (nextPath && nextName) {
+            const nextBase = nextPath.split(/[/\\]/).pop() || nextName;
+            const raw = readFileSync(nextPath, 'utf-8');
             const parsed = markdownToTiptap(raw);
-            setActiveDocument(parsed.document, parsed.title, next.path, next.name.startsWith(TEMP_PREFIX), new Date(next.mtime), parsed.metadata, undefined);
-            return { switched: true, newDoc: { document: getDocument(), title: getTitle(), filename: next.name } };
+            const mtime = statSync(nextPath).mtimeMs;
+            setActiveDocument(parsed.document, parsed.title, nextPath, nextBase.startsWith(TEMP_PREFIX), new Date(mtime), parsed.metadata, undefined);
+            return { switched: true, newDoc: { document: getDocument(), title: getTitle(), filename: nextName } };
         }
     }
     return { switched: false };

package/dist/server/git-sync.js ADDED Viewed

@@ -0,0 +1,273 @@
+/**
+ * Git sync module: all git/gh CLI interactions for GitHub sync.
+ * Uses child_process.execFile with shell:true (required on Windows).
+ */
+import { execFile } from 'child_process';
+import { existsSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { getDataDir, readConfig, saveConfig } from './helpers.js';
+import { save, cancelDebouncedSave } from './state.js';
+const GITIGNORE_CONTENT = `config.json\n.versions/\n`;
+const NETWORK_TIMEOUT = 30000;
+let currentSyncState = 'unconfigured';
+let lastError;
+function exec(cmd, args, cwd, timeout = 10000) {
+    // Quote args with spaces so shell: true doesn't split them
+    const safeArgs = args.map(a => a.includes(' ') ? `"${a}"` : a);
+    return new Promise((resolve, reject) => {
+        execFile(cmd, safeArgs, { cwd, shell: true, timeout }, (err, stdout, stderr) => {
+            if (err)
+                reject(new Error(stderr?.trim() || err.message));
+            else
+                resolve(stdout.trim());
+        });
+    });
+}
+export async function isGitInstalled() {
+    try {
+        await exec('git', ['--version'], getDataDir());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function isGhInstalled() {
+    try {
+        await exec('gh', ['--version'], getDataDir());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function isGhAuthenticated() {
+    try {
+        await exec('gh', ['auth', 'status'], getDataDir());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isGitRepo() {
+    return existsSync(join(getDataDir(), '.git'));
+}
+function ensureGitignore() {
+    const gitignorePath = join(getDataDir(), '.gitignore');
+    if (!existsSync(gitignorePath)) {
+        writeFileSync(gitignorePath, GITIGNORE_CONTENT, 'utf-8');
+    }
+}
+/** Count files that have changed since last commit (or all files if no commits yet). */
+async function countPendingFiles() {
+    if (!isGitRepo())
+        return 0;
+    try {
+        // Check for any changes (staged + unstaged + untracked)
+        const status = await exec('git', ['status', '--porcelain'], getDataDir());
+        if (!status)
+            return 0;
+        return status.split('\n').filter(Boolean).length;
+    }
+    catch {
+        return 0;
+    }
+}
+/** Return the list of pending files with their status. */
+export async function getPendingFiles() {
+    if (!isGitRepo())
+        return [];
+    try {
+        const output = await exec('git', ['status', '--porcelain'], getDataDir());
+        if (!output)
+            return [];
+        return output.split('\n').filter(Boolean).map(line => {
+            const code = line.substring(0, 2);
+            const file = line.substring(3);
+            let status = 'modified';
+            if (code.includes('?') || code.includes('A'))
+                status = 'added';
+            else if (code.includes('D'))
+                status = 'deleted';
+            else if (code.includes('R'))
+                status = 'renamed';
+            return { status, file };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+export async function getSyncStatus() {
+    const config = readConfig();
+    if (!config.gitConfigured || !isGitRepo()) {
+        return { state: 'unconfigured' };
+    }
+    if (currentSyncState === 'syncing') {
+        return { state: 'syncing' };
+    }
+    if (currentSyncState === 'error' && lastError) {
+        return { state: 'error', error: lastError, lastSyncTime: config.lastSyncTime };
+    }
+    const pending = await countPendingFiles();
+    return {
+        state: pending > 0 ? 'pending' : 'synced',
+        pendingFiles: pending,
+        lastSyncTime: config.lastSyncTime,
+    };
+}
+export async function getCapabilities() {
+    const [git, gh] = await Promise.all([isGitInstalled(), isGhInstalled()]);
+    let ghAuth = false;
+    if (gh)
+        ghAuth = await isGhAuthenticated();
+    let remoteUrl;
+    if (isGitRepo()) {
+        try {
+            remoteUrl = await exec('git', ['remote', 'get-url', 'origin'], getDataDir());
+        }
+        catch { /* no remote */ }
+    }
+    return {
+        gitInstalled: git,
+        ghInstalled: gh,
+        ghAuthenticated: ghAuth,
+        existingRepo: isGitRepo(),
+        remoteUrl,
+    };
+}
+async function initRepo() {
+    if (!isGitRepo()) {
+        await exec('git', ['init'], getDataDir());
+    }
+    ensureGitignore();
+    // Ensure git user is configured (required for commits)
+    try {
+        await exec('git', ['config', 'user.name'], getDataDir());
+    }
+    catch {
+        await exec('git', ['config', 'user.name', 'OpenWriter'], getDataDir());
+    }
+    try {
+        await exec('git', ['config', 'user.email'], getDataDir());
+    }
+    catch {
+        await exec('git', ['config', 'user.email', 'openwriter@local'], getDataDir());
+    }
+}
+async function initialCommit() {
+    await exec('git', ['add', '-A'], getDataDir());
+    // Check if there's anything staged
+    const status = await exec('git', ['status', '--porcelain'], getDataDir());
+    if (!status)
+        return; // Nothing to commit
+    await exec('git', ['commit', '-m', 'Initial sync from OpenWriter'], getDataDir());
+    // Ensure branch is named 'main'
+    await exec('git', ['branch', '-M', 'main'], getDataDir());
+}
+export async function setupWithGh(repoName, isPrivate) {
+    await initRepo();
+    await initialCommit();
+    const visibility = isPrivate ? '--private' : '--public';
+    // Create repo without --push, then push separately for better error control
+    await exec('gh', ['repo', 'create', repoName, visibility, '--source=.', '--remote=origin'], getDataDir(), NETWORK_TIMEOUT);
+    await exec('git', ['push', '-u', 'origin', 'main'], getDataDir(), NETWORK_TIMEOUT);
+    saveConfig({
+        gitConfigured: true,
+        repoName,
+        lastSyncTime: new Date().toISOString(),
+    });
+    currentSyncState = 'synced';
+}
+export async function setupWithPat(pat, repoName, isPrivate) {
+    // Create repo via GitHub REST API
+    const res = await fetch('https://api.github.com/user/repos', {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${pat}`,
+            'Content-Type': 'application/json',
+            Accept: 'application/vnd.github+json',
+        },
+        body: JSON.stringify({ name: repoName, private: isPrivate, auto_init: false }),
+    });
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        throw new Error(body.message || `GitHub API error: ${res.status}`);
+    }
+    const repo = await res.json();
+    const remoteUrl = `https://${pat}@github.com/${repo.full_name}.git`;
+    await initRepo();
+    await initialCommit();
+    // Set remote
+    try {
+        await exec('git', ['remote', 'remove', 'origin'], getDataDir());
+    }
+    catch { /* no remote */ }
+    await exec('git', ['remote', 'add', 'origin', remoteUrl], getDataDir());
+    await exec('git', ['push', '-u', 'origin', 'main'], getDataDir(), NETWORK_TIMEOUT);
+    saveConfig({
+        gitConfigured: true,
+        gitPat: pat,
+        repoName,
+        gitRemote: repo.html_url,
+        lastSyncTime: new Date().toISOString(),
+    });
+    currentSyncState = 'synced';
+}
+export async function connectExisting(remoteUrl, pat) {
+    await initRepo();
+    await initialCommit();
+    // Embed PAT in URL if provided
+    let finalUrl = remoteUrl;
+    if (pat && remoteUrl.startsWith('https://')) {
+        finalUrl = remoteUrl.replace('https://', `https://${pat}@`);
+    }
+    try {
+        await exec('git', ['remote', 'remove', 'origin'], getDataDir());
+    }
+    catch { /* no remote */ }
+    await exec('git', ['remote', 'add', 'origin', finalUrl], getDataDir());
+    await exec('git', ['push', '-u', 'origin', 'main'], getDataDir(), NETWORK_TIMEOUT);
+    saveConfig({
+        gitConfigured: true,
+        gitPat: pat,
+        gitRemote: remoteUrl,
+        lastSyncTime: new Date().toISOString(),
+    });
+    currentSyncState = 'synced';
+}
+export async function pushSync(onStatus) {
+    currentSyncState = 'syncing';
+    lastError = undefined;
+    onStatus({ state: 'syncing' });
+    try {
+        // Flush current document to disk first (cancel debounce to ensure immediate write)
+        cancelDebouncedSave();
+        save();
+        ensureGitignore();
+        await exec('git', ['add', '-A'], getDataDir());
+        // Check if there's anything to commit
+        const status = await exec('git', ['status', '--porcelain'], getDataDir());
+        if (status) {
+            const timestamp = new Date().toLocaleString('en-US', {
+                month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit',
+            });
+            await exec('git', ['commit', '-m', `Sync: ${timestamp}`], getDataDir());
+        }
+        await exec('git', ['push'], getDataDir(), NETWORK_TIMEOUT);
+        const now = new Date().toISOString();
+        saveConfig({ lastSyncTime: now });
+        currentSyncState = 'synced';
+        const result = { state: 'synced', lastSyncTime: now, pendingFiles: 0 };
+        onStatus(result);
+        return result;
+    }
+    catch (err) {
+        currentSyncState = 'error';
+        lastError = err.message;
+        const result = { state: 'error', error: err.message };
+        onStatus(result);
+        return result;
+    }
+}