server.js

import axios from 'axios';
import { exec } from 'child_process';
import cors from 'cors';
import 'dotenv/config';
import express from 'express';
import fs from 'fs-extra';
import matter from 'gray-matter';
import multer from 'multer';
import path from 'path';
import { fileURLToPath } from 'url';
import { createHash, randomInt } from 'crypto';
import { promisify } from 'util';
import bcrypt from 'bcryptjs';
import session from 'express-session';
import { createTurndownService, markdownToHtml } from './scripts/markdown.js';
import { commitAll, push } from './scripts/git.js';
import { draftPath, postPath } from './scripts/post-path.js';
import { corsOrigins, pushAllowed, sessionSecret } from './scripts/server-config.js';
import { imageExtension, MAX_IMAGE_UPLOAD_BYTES } from './scripts/image-upload.js';

const execAsync = promisify(exec);

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const app = express();
const port = process.env.SERVER_PORT;

// Cross-origin access only for the origins listed in CORS_ORIGINS (none by default).
const CORS_ORIGINS = corsOrigins(process.env.CORS_ORIGINS);
if (CORS_ORIGINS.length) {
    app.use(cors({ origin: CORS_ORIGINS, credentials: true }));
}
app.use(express.json({ limit: '50mb' }));

// Configuration from Env
const CONTENT_DIR_REL = process.env.CONTENT_DIR;
const STATIC_DIR_REL = process.env.STATIC_DIR;
const DRAFTS_DIR_REL = process.env.DRAFTS_DIR;

const POSTS_DIR = path.resolve(__dirname, CONTENT_DIR_REL);
const STATIC_DIR = path.resolve(__dirname, STATIC_DIR_REL);
const DRAFTS_DIR = path.resolve(__dirname, DRAFTS_DIR_REL);

// Auth Configuration
const AUTH_ENABLED = process.env.AUTH_ENABLED === 'true';
const AUTH_USERNAME = process.env.AUTH_USERNAME;
// Docker Compose may use $$ to escape $, so we unescape it for the app
const AUTH_PASSWORD_HASH = process.env.AUTH_PASSWORD_HASH?.replace(/\$\$/g, '$');
// Refuses to start when authentication is on and no secret is set.
const SESSION_SECRET = sessionSecret(process.env);

// Auth Middleware
const authGuard = (req, res, next) => {
    if (!AUTH_ENABLED) return next();
    if (req.session.user) return next();

    // Allow public access to auth routes and /api/me
    if (req.path.startsWith('/api/me') || req.path === '/auth/login' || req.path === '/auth/logout') return next();

    res.status(401).json({ error: 'Unauthorized' });
};

if (AUTH_ENABLED) {
    app.use(session({
        secret: SESSION_SECRET,
        resave: false,
        saveUninitialized: false,
        cookie: {
            secure: false, // Set to true if using HTTPS
            httpOnly: true,
            maxAge: 24 * 60 * 60 * 1000 // 24 hours
        }
    }));
}

// Auth Routes
if (AUTH_ENABLED) {
    app.post('/auth/login', async (req, res) => {
        const { username, password } = req.body;

        if (!AUTH_USERNAME || !AUTH_PASSWORD_HASH) {
            return res.status(500).json({ error: 'Server authentication not configured correctly' });
        }

        if (username === AUTH_USERNAME) {
            const match = await bcrypt.compare(password, AUTH_PASSWORD_HASH);
            if (match) {
                req.session.user = { displayName: AUTH_USERNAME };
                return res.json({ success: true, user: req.session.user });
            }
        }

        res.status(401).json({ error: 'Invalid username or password' });
    });

    app.get('/api/me', (req, res) => {
        res.json({
            user: req.session.user || null,
            authEnabled: true,
            authType: 'manual'
        });
    });

    app.get('/auth/logout', (req, res) => {
        req.session.destroy();
        res.json({ success: true });
    });
} else {
    app.get('/api/me', (req, res) => {
        res.json({ user: { displayName: 'Guest' }, authEnabled: false });
    });
}

// Apply authGuard to all /api routes
app.use('/api', authGuard);

console.log('Inscript Config:');
console.log('Posts Dir:', POSTS_DIR);
console.log('Static Dir:', STATIC_DIR);
console.log('Drafts Dir:', DRAFTS_DIR);

// Serve custom favicon
app.get('/favicon.png', (req, res) => {
    const FAVICON_FILE = process.env.FAVICON;
    if (FAVICON_FILE && !FAVICON_FILE.includes('favicon_default.png')) {
        const customFaviconPath = path.resolve(STATIC_DIR, FAVICON_FILE);
        if (fs.existsSync(customFaviconPath)) {
            return res.sendFile(customFaviconPath);
        }
    }
    // Fallback to default
    const defaultFavicon = path.join(__dirname, 'assets', 'favicon_default.png');
    if (fs.existsSync(defaultFavicon)) {
        res.sendFile(defaultFavicon);
    } else {
        res.status(404).send('Favicon not found');
    }
});

// Serve static files from the configured static directory. Browsers must not guess another
// type, and an SVG may not run script or load anything, since these share the editor's address.
const SVG_POLICY = "default-src 'none'; style-src 'unsafe-inline'; img-src data:; sandbox";
app.use(express.static(STATIC_DIR, {
    setHeaders: (res, filePath) => {
        res.setHeader('X-Content-Type-Options', 'nosniff');
        if (path.extname(filePath).toLowerCase() === '.svg') res.setHeader('Content-Security-Policy', SVG_POLICY);
    }
}));

// Ensure directories exist
fs.ensureDirSync(POSTS_DIR);
fs.ensureDirSync(DRAFTS_DIR);

// Markdown <-> editor HTML (see scripts/markdown.js)
const turndownService = createTurndownService();

// Sent when a request names a post file that is not a plain *.md name inside the posts folder.
const INVALID_FILENAME = 'Invalid post file name';

// Identifies a version of a post's file. A draft records the version it was based on, so
// opening the post can tell when the file changed outside Inscript while the draft existed.
const fileHash = (content) => createHash('sha256').update(content).digest('hex');

// Uploads are held in memory up to MAX_IMAGE_UPLOAD_BYTES, so their content can be checked
// before anything is written. The saved name and extension come from the server, never the client.
const upload = multer({ storage: multer.memoryStorage(), limits: { fileSize: MAX_IMAGE_UPLOAD_BYTES, files: 1 } });
const UPLOAD_FILENAME_RANGE = 1e9;
const NOT_AN_IMAGE = 'Only PNG, JPEG, GIF, WebP and AVIF images can be uploaded';

// List all posts
app.get('/api/youtube/search', async (req, res) => {
    const { q } = req.query;
    if (!q) return res.json({ items: [] });

    const SOURCES = [
        { url: 'https://invidious.ducks.party', type: 'invidious' }, // Verified working Feb 2026
        { url: 'https://iv.ggtyler.dev', type: 'invidious' },
        { url: 'https://invidious.projectsegfau.lt', type: 'invidious' },
        { url: 'https://pipedapi.tokhmi.xyz', type: 'piped' },
        { url: 'https://pipedapi.lunar.icu', type: 'piped' },
        { url: 'https://api.piped.yt', type: 'piped' }
    ];

    const axiosConfig = {
        timeout: 5000,
        headers: {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
        }
    };

    for (const source of SOURCES) {
        try {
            if (source.type === 'piped') {
                const response = await axios.get(`${source.url}/search?q=${encodeURIComponent(q)}&filter=videos`, axiosConfig);
                if (response.data && response.data.items) {
                    return res.json(response.data);
                }
            } else if (source.type === 'invidious') {
                const response = await axios.get(`${source.url}/api/v1/search?q=${encodeURIComponent(q)}&type=video`, axiosConfig);
                if (Array.isArray(response.data)) {
                    const items = response.data.map(v => ({
                        url: `/watch?v=${v.videoId}`,
                        title: v.title,
                        thumbnail: v.videoThumbnails?.find(t => t.quality === 'medium')?.url || v.videoThumbnails?.[0]?.url,
                        uploaderName: v.author,
                        views: v.viewCount,
                        duration: v.lengthSeconds
                    }));
                    return res.json({ items });
                }
            }
        } catch (err) {
            console.warn(`YouTube Search failed for ${source.url}: ${err.code || err.response?.status || err.message}`);
            continue;
        }
    }

    res.status(502).json({ error: 'All YouTube search sources failed' });
});

app.get('/api/posts', async (req, res) => {
    try {
        const files = await fs.readdir(POSTS_DIR);
        const draftFiles = await fs.readdir(DRAFTS_DIR).catch(() => []);

        const posts = await Promise.all(
            files.filter(f => f.endsWith('.md')).map(async (filename) => {
                const filePath = path.join(POSTS_DIR, filename);
                const content = await fs.readFile(filePath, 'utf8');
                const stats = await fs.stat(filePath);
                const { data } = matter(content);

                const hasDraft = draftFiles.includes(`${filename}.json`);

                // Use frontmatter created/modified or fallback to file stats
                const created = data.created
                    ? new Date(data.created).toISOString()
                    : (stats.birthtime || stats.ctime).toISOString();

                const modified = data.modified
                    ? new Date(data.modified).toISOString()
                    : stats.mtime.toISOString();

                return {
                    filename,
                    title: data.title || filename,
                    created,
                    modified,
                    hasDraft,
                    isUnpublished: false,
                    tags: data.tags || [],
                    categories: data.categories || [],
                    ...data // Spread other frontmatter fields like 'type'
                };
            })
        );

        // Handle Orphan Drafts (Unpublished Posts)
        const publishedFilenames = new Set(files.filter(f => f.endsWith('.md')));
        const orphanDrafts = draftFiles.filter(f => f.endsWith('.md.json') && !publishedFilenames.has(f.replace('.json', '')));

        const unpublishedPosts = await Promise.all(
            orphanDrafts.map(async (draftFilename) => {
                const filePath = path.join(DRAFTS_DIR, draftFilename);
                const draft = await fs.readJson(filePath);
                const filename = draftFilename.replace('.json', '');

                // Get latest state from history
                const latest = (draft.history && draft.history[draft.currentIndex]) ||
                    (draft.history && draft.history.length > 0 ? draft.history[draft.history.length - 1] : null) ||
                    { title: filename.replace('.md', ''), timestamp: new Date().toISOString() };

                return {
                    filename,
                    title: latest.title || filename,
                    created: latest.timestamp, // Draft creation/mod time
                    modified: latest.timestamp,
                    hasDraft: true,
                    isUnpublished: true,
                    tags: latest.tags || [],
                    categories: latest.categories || [],
                    type: draft.type
                };
            })
        );

        res.json([...posts, ...unpublishedPosts]);
    } catch (err) {
        res.status(500).json({ error: err.message });
    }
});

// Get single post (with merged draft if exists)
app.get('/api/posts/:filename', async (req, res) => {
    try {
        const filePath = postPath(POSTS_DIR, req.params.filename);
        const draftFile = draftPath(DRAFTS_DIR, req.params.filename);
        if (!filePath || !draftFile) return res.status(400).json({ error: INVALID_FILENAME });

        let frontmatter = {};
        let html = '';
        let title = req.params.filename.replace('.md', '');
        let savedHtml = '';
        let savedTitle = '';
        let isUnpublished = false;

        let sourceHash = null;

        // Check if original file exists
        const fileExists = await fs.pathExists(filePath);

        if (fileExists) {
            const content = await fs.readFile(filePath, 'utf8');
            sourceHash = fileHash(content);
            const parsed = matter(content);
            frontmatter = parsed.data;
            html = markdownToHtml(parsed.content);
            title = frontmatter.title || title;
            savedHtml = html;
            savedTitle = title;
        } else {
            // Check if it's an unpublished draft
            const draftExists = await fs.pathExists(draftFile);
            if (!draftExists) {
                return res.status(404).json({ error: 'Post not found' });
            }
            isUnpublished = true;
        }

        let history = [];
        let currentIndex = 0;
        // The file changed after the draft was based on it (edited or pulled outside Inscript).
        // Drafts written before this was recorded carry no sourceHash and count as unchanged.
        let draftBaseChanged = false;
        // The version the history view compares against (the post as last saved), if kept.
        let reference = null;

        const hasDraft = await fs.pathExists(draftFile);
        if (hasDraft) {
            const draft = await fs.readJson(draftFile);
            draftBaseChanged = !!(draft.sourceHash && sourceHash && draft.sourceHash !== sourceHash);
            reference = draft.reference || null;
            const activeItem = draft.history && draft.history[draft.currentIndex];
            if (activeItem) {
                // Drafts store HTML directly, but if we ever re-parse raw MD, we might need this.
                // Currently draft history is HTML. If the draft was loaded from MD initially, it already went through markdownToHtml.
                html = activeItem.html;
                title = activeItem.title;
            }
            history = draft.history || [];
            currentIndex = draft.currentIndex || 0;

            // For unpublished drafts, populate frontmatter from latest draft state
            if (isUnpublished && activeItem) {
                frontmatter = {
                    title: activeItem.title,
                    tags: activeItem.tags || [],
                    categories: activeItem.categories || [],
                    created: activeItem.timestamp,
                    modified: activeItem.timestamp
                };
                savedTitle = activeItem.title;
                // savedHtml remains empty for unpublished drafts as there is no "published" version
            }
        }

        res.json({ filename: req.params.filename, frontmatter, html, title, savedHtml, savedTitle, hasDraft, history, currentIndex, isUnpublished, sourceHash, draftBaseChanged, reference });
    } catch (err) {
        res.status(500).json({ error: err.message });
    }
});

// Save post (and clear draft)
app.post('/api/posts', async (req, res) => {
    try {
        const { filename, frontmatter, html } = req.body;
        const filePath = postPath(POSTS_DIR, filename);
        const draftFile = draftPath(DRAFTS_DIR, filename);
        if (!filePath || !draftFile) return res.status(400).json({ error: INVALID_FILENAME });
        const markdown = turndownService.turndown(html);

        // Enforce modified time. Preserve existing created time or set it if missing.
        const now = new Date().toISOString();
        frontmatter.modified = now;
        if (!frontmatter.created) {
            frontmatter.created = now;
        }
        const fileContent = matter.stringify(markdown, frontmatter);
        await fs.writeFile(filePath, fileContent);

        // Clear draft on successful permanent save
        await fs.remove(draftFile).catch(() => { });

        res.json({ success: true, frontmatter, sourceHash: fileHash(fileContent) });
    } catch (err) {
        res.status(500).json({ error: err.message });
    }
});

// Draft Management
app.post('/api/drafts/:filename', async (req, res) => {
    try {
        const { history, currentIndex, sourceHash, reference } = req.body;
        const draftFile = draftPath(DRAFTS_DIR, req.params.filename);
        if (!draftFile) return res.status(400).json({ error: INVALID_FILENAME });

        // Server is now a dumb store for the client-managed history stack, plus the file
        // version it is based on and the history view's reference (see GET /api/posts/:filename).
        await fs.writeJson(draftFile, {
            history,
            currentIndex,
            sourceHash: sourceHash || null,
            reference: reference || null
        }, { spaces: 4 });

        res.json({ success: true });
    } catch (err) {
        res.status(500).json({ error: err.message });
    }
});

app.delete('/api/drafts/:filename', async (req, res) => {
    try {
        const draftFile = draftPath(DRAFTS_DIR, req.params.filename);
        if (!draftFile) return res.status(400).json({ error: INVALID_FILENAME });
        await fs.remove(draftFile);
        res.json({ success: true });
    } catch (err) {
        res.status(500).json({ error: err.message });
    }
});

// Publish static site
app.post('/api/publish', async (req, res) => {
    try {
        console.log('🚀 Publishing static site...');
        // Execute the publish script defined in package.json
        // Increase maxBuffer for large Vite build outputs (10MB)
        const { stdout, stderr } = await execAsync('npm run publish', {
            cwd: __dirname,
            maxBuffer: 10 * 1024 * 1024
        });
        console.log('Publish Output:', stdout);
        if (stderr) console.error('Publish Error Output:', stderr);
        res.json({ success: true, output: stdout });
    } catch (err) {
        console.error('Publish Failed:', err);
        // Include stderr in the error response if available for better debugging
        const errorMessage = err.stderr ? `${err.message}\n\nStderr: ${err.stderr}` : err.message;
        res.status(500).json({ error: errorMessage });
    }
});

// Git Commit
app.post('/api/git/commit', async (req, res) => {
    try {
        const { message } = req.body;
        console.log('📝 Committing changes');

        // Ensure we are in the project root (one level up from inscript/ if server.js is in inscript/)
        const projectRoot = path.join(__dirname, '..');

        const { output } = await commitAll(projectRoot, message);
        res.json({ success: true, output });
    } catch (err) {
        res.status(err instanceof RangeError ? 400 : 500).json({ error: err.message });
    }
});

// Git Push, only when ALLOW_PUSH is on: the editor hides the button otherwise, and the
// server enforces the same setting.
app.post('/api/git/push', async (req, res) => {
    if (!pushAllowed(process.env)) {
        return res.status(403).json({ error: 'Pushing is turned off. Set ALLOW_PUSH=true in .env to allow it.' });
    }
    try {
        console.log('⬆️ Pushing to remote...');
        const projectRoot = path.join(__dirname, '..');
        const output = await push(projectRoot);
        res.json({ success: true, output });
    } catch (err) {
        res.status(500).json({ error: err.message });
    }
});

app.delete('/api/posts/:filename', async (req, res) => {
    try {
        const { filename } = req.params;
        const filePath = postPath(POSTS_DIR, filename);
        const draftFile = draftPath(DRAFTS_DIR, filename);
        if (!filePath || !draftFile) return res.status(400).json({ error: INVALID_FILENAME });

        if (await fs.pathExists(filePath)) await fs.remove(filePath);
        if (await fs.pathExists(draftFile)) await fs.remove(draftFile);

        res.json({ success: true });
    } catch (err) {
        res.status(500).json({ error: err.message });
    }
});

// Upload image
app.post('/api/upload', (req, res) => {
    upload.single('image')(req, res, async (uploadError) => {
        if (uploadError) {
            const tooLarge = uploadError.code === 'LIMIT_FILE_SIZE';
            return res.status(tooLarge ? 413 : 400).json({ error: tooLarge ? `The image is larger than ${MAX_IMAGE_UPLOAD_BYTES / 1024 / 1024} MB` : uploadError.message });
        }
        try {
            if (!req.file) return res.status(400).json({ error: 'No file uploaded' });
            const extension = imageExtension(req.file.buffer);
            if (!extension) return res.status(415).json({ error: NOT_AN_IMAGE });
            const filename = `${Date.now()}-${randomInt(UPLOAD_FILENAME_RANGE)}${extension}`;
            await fs.writeFile(path.join(STATIC_DIR, filename), req.file.buffer, { flag: 'wx' });
            res.json({ url: filename });
        } catch (err) {
            res.status(500).json({ error: err.message });
        }
    });
});

// Helper for recursive files
async function getFiles(dir) {
    const subdirs = await fs.readdir(dir);
    const files = await Promise.all(subdirs.map(async (subdir) => {
        const res = path.resolve(dir, subdir);
        return (await fs.stat(res)).isDirectory() ? await getFiles(res) : res;
    }));
    return Array.prototype.concat(...files);
}


app.get('/api/images', async (req, res) => {
    try {
        const allFiles = await getFiles(STATIC_DIR);
        const images = allFiles
            .filter(f => /\.(png|jpg|jpeg|gif|svg|webp)$/i.test(f))
            .map(fullPath => {
                const relativePath = path.relative(STATIC_DIR, fullPath);
                return {
                    url: `/${relativePath}`,
                    name: relativePath
                };
            });
        res.json(images);
    } catch (err) {
        res.status(500).json({ error: err.message });
    }
});

app.listen(port, '0.0.0.0', () => {
    console.log(`Inscript Server running at http://0.0.0.0:${port}`);
});