openwriter 0.40.0 → 0.40.1

package/dist/server/git-sync.js

@@ -1,273 +0,0 @@
-/**
- * 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;
-    }
-}

package/dist/server/marks.js

@@ -1,182 +0,0 @@
-/**
- * Agent Marks: sidecar JSON storage for inline user feedback.
- * Each document gets a sidecar file at DATA_DIR/_marks/{filename}.json.
- */
-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 getMarksDir() { return join(getDataDir(), '_marks'); }
-function ensureMarksDir() {
-    ensureDataDir();
-    if (!existsSync(getMarksDir()))
-        mkdirSync(getMarksDir(), { recursive: true });
-}
-function markFilePath(filename) {
-    // Sanitize: replace path separators to avoid nested paths
-    const safe = filename.replace(/[/\\]/g, '_');
-    return join(getMarksDir(), `${safe}.json`);
-}
-function readMarkFile(filename) {
-    const path = markFilePath(filename);
-    if (!existsSync(path))
-        return { marks: [] };
-    try {
-        return JSON.parse(readFileSync(path, 'utf-8'));
-    }
-    catch {
-        return { marks: [] };
-    }
-}
-function writeMarkFile(filename, data) {
-    ensureMarksDir();
-    const path = markFilePath(filename);
-    if (data.marks.length === 0) {
-        // Clean up empty sidecar files
-        if (existsSync(path))
-            unlinkSync(path);
-        return;
-    }
-    writeFileSync(path, JSON.stringify(data, null, 2));
-}
-export function addMark(filename, text, note, nodeId, nodeIds) {
-    const data = readMarkFile(filename);
-    const mark = {
-        id: randomUUID().slice(0, 8),
-        text,
-        note,
-        nodeId,
-        ...(nodeIds && nodeIds.length > 1 ? { nodeIds } : {}),
-        createdAt: new Date().toISOString(),
-    };
-    data.marks.push(mark);
-    writeMarkFile(filename, data);
-    return mark;
-}
-export function getMarks(filename) {
-    if (filename) {
-        const data = readMarkFile(filename);
-        if (data.marks.length === 0)
-            return {};
-        return { [filename]: data.marks };
-    }
-    // All docs: scan _marks directory
-    ensureMarksDir();
-    const result = {};
-    try {
-        const files = readdirSync(getMarksDir());
-        for (const file of files) {
-            if (!file.endsWith('.json'))
-                continue;
-            const docFilename = file.replace(/\.json$/, '').replace(/_/g, ' ');
-            // Read raw to avoid filename roundtrip issues
-            const path = join(getMarksDir(), file);
-            try {
-                const data = JSON.parse(readFileSync(path, 'utf-8'));
-                if (data.marks.length > 0)
-                    result[docFilename] = data.marks;
-            }
-            catch { /* skip corrupt files */ }
-        }
-    }
-    catch { /* dir doesn't exist yet */ }
-    return result;
-}
-export function getMarkCount(filename) {
-    return readMarkFile(filename).marks.length;
-}
-/** Count marks across all documents, optionally excluding one filename. */
-export function getGlobalMarkSummary(excludeFilename) {
-    ensureMarksDir();
-    let totalMarks = 0;
-    let docCount = 0;
-    try {
-        const files = readdirSync(getMarksDir());
-        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(getMarksDir(), file);
-            try {
-                const data = JSON.parse(readFileSync(path, 'utf-8'));
-                if (data.marks.length > 0) {
-                    totalMarks += data.marks.length;
-                    docCount++;
-                }
-            }
-            catch { /* skip */ }
-        }
-    }
-    catch { /* dir doesn't exist */ }
-    return { totalMarks, docCount };
-}
-export function editMark(filename, id, note) {
-    const data = readMarkFile(filename);
-    const mark = data.marks.find((m) => m.id === id);
-    if (!mark)
-        return null;
-    mark.note = note;
-    writeMarkFile(filename, data);
-    return mark;
-}
-export function resolveMarks(ids) {
-    const idSet = new Set(ids);
-    const resolved = [];
-    ensureMarksDir();
-    try {
-        const files = readdirSync(getMarksDir());
-        for (const file of files) {
-            if (!file.endsWith('.json'))
-                continue;
-            const filePath = join(getMarksDir(), 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)) {
-                        resolved.push(m.id);
-                        return false;
-                    }
-                    return true;
-                });
-                if (data.marks.length !== before) {
-                    const docFilename = file.replace(/\.json$/, '').replace(/_/g, ' ');
-                    writeMarkFile(docFilename, data);
-                }
-            }
-            catch { /* skip */ }
-        }
-    }
-    catch { /* dir doesn't exist */ }
-    return resolved;
-}
-export function pruneStaleMarks(filename, validNodeIds) {
-    const data = readMarkFile(filename);
-    if (data.marks.length === 0)
-        return 0;
-    const validSet = new Set(validNodeIds);
-    const before = data.marks.length;
-    data.marks = data.marks.filter((m) => {
-        // Multi-node mark: keep if ANY nodeId is still valid
-        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)
-        writeMarkFile(filename, data);
-    return pruned;
-}
-/** Rename a mark sidecar file when a document is renamed. */
-export function renameMark(oldFilename, newFilename) {
-    const oldPath = markFilePath(oldFilename);
-    if (!existsSync(oldPath))
-        return;
-    const newPath = markFilePath(newFilename);
-    renameSync(oldPath, newPath);
-}

package/dist/server/sync-routes.js

@@ -1,75 +0,0 @@
-/**
- * Express routes for GitHub sync.
- * Mounted in index.ts — follows version-routes.ts pattern.
- */
-import { Router } from 'express';
-import { getSyncStatus, getCapabilities, getPendingFiles, setupWithGh, setupWithPat, connectExisting, pushSync, } from './git-sync.js';
-export function createSyncRouter(broadcastSyncStatus) {
-    const router = Router();
-    router.get('/api/sync/status', async (_req, res) => {
-        try {
-            res.json(await getSyncStatus());
-        }
-        catch (err) {
-            res.status(500).json({ state: 'error', error: err.message });
-        }
-    });
-    router.get('/api/sync/capabilities', async (_req, res) => {
-        try {
-            res.json(await getCapabilities());
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
-    });
-    router.get('/api/sync/pending', async (_req, res) => {
-        try {
-            res.json(await getPendingFiles());
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
-    });
-    router.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();
-            broadcastSyncStatus(status);
-            res.json({ success: true, status });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
-    });
-    router.post('/api/sync/push', async (_req, res) => {
-        try {
-            const result = await pushSync(broadcastSyncStatus);
-            res.json(result);
-        }
-        catch (err) {
-            res.status(500).json({ state: 'error', error: err.message });
-        }
-    });
-    return router;
-}