deckrun 1.3.0

package/dist/index.js

@@ -0,0 +1,538 @@
+#!/usr/bin/env node
+import { readFileSync } from "fs";
+import { readFile } from "fs/promises";
+import { createServer } from "http";
+import { createRequire } from "module";
+import { resolve, dirname, basename, extname } from "path";
+import { Command } from "commander";
+import open from "open";
+import { parseSlides } from "./parser.js";
+import { generateHtml, generateDocHtml, renderSlide } from "./generate.js";
+import { DEFAULT_SIZE, DEFAULT_THEME, findFont, findSize, findTheme, fontListing, fontName, resolveSizeName, resolveThemeName, THEMES, themeListing, sizeListing, } from "./themes.js";
+import { generateEditorHtml } from "./editor.js";
+import { generatePreviewHtml } from "./preview.js";
+import { findBrowser, renderPdfSerial, PdfError } from "./pdf.js";
+const c = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    cyan: "\x1b[36m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    magenta: "\x1b[35m",
+};
+function packageVersion() {
+    try {
+        const require = createRequire(import.meta.url);
+        return require("../package.json").version;
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+const MIME = {
+    ".html": "text/html; charset=utf-8",
+    ".htm": "text/html; charset=utf-8",
+    ".css": "text/css",
+    ".js": "application/javascript",
+    ".mjs": "application/javascript",
+    ".json": "application/json",
+    ".md": "text/markdown; charset=utf-8",
+    ".txt": "text/plain; charset=utf-8",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".webp": "image/webp",
+    ".ico": "image/x-icon",
+    ".avif": "image/avif",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".ttf": "font/ttf",
+};
+function getMime(filepath) {
+    return MIME[extname(filepath).toLowerCase()] ?? "application/octet-stream";
+}
+async function findFreePort(preferred) {
+    return new Promise((resolvePort) => {
+        const server = createServer();
+        server.listen(preferred, () => {
+            const addr = server.address();
+            server.close(() => resolvePort(addr.port));
+        });
+        server.on("error", () => {
+            // Preferred port is taken, take whatever the OS offers.
+            const fallback = createServer();
+            fallback.listen(0, () => {
+                const addr = fallback.address();
+                fallback.close(() => resolvePort(addr.port));
+            });
+        });
+    });
+}
+/** First heading of the deck, with inline markup stripped. */
+function deckTitle(slides, fallback) {
+    const heading = slides[0]?.html.match(/<h[1-6][^>]*>([\s\S]*?)<\/h[1-6]>/i);
+    const text = heading ? heading[1].replace(/<[^>]+>/g, "").trim() : "";
+    return text || fallback;
+}
+/** An HTML doc's own `<title>`, with inline markup stripped. */
+function docTitle(html, fallback) {
+    const match = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+    const text = match ? match[1].replace(/<[^>]+>/g, "").trim() : "";
+    return text || fallback;
+}
+/** A deck name reduced to something safe for a Content-Disposition header. */
+function safeFilename(name) {
+    const slug = name
+        .trim()
+        .toLowerCase()
+        .replace(/\.(md|markdown)$/, "")
+        .replace(/[^a-z0-9._-]+/g, "-")
+        .replace(/^-|-$/g, "");
+    return slug || "deck";
+}
+const MAX_BODY = 32 * 1024 * 1024;
+function readBody(req) {
+    return new Promise((resolveBody, rejectBody) => {
+        const chunks = [];
+        let size = 0;
+        let overflowed = false;
+        req.on("data", (chunk) => {
+            if (overflowed)
+                return;
+            size += chunk.length;
+            if (size > MAX_BODY) {
+                // Reject now but keep the socket open long enough to answer with 413.
+                overflowed = true;
+                chunks.length = 0;
+                rejectBody(new Error("request body too large"));
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on("end", () => {
+            if (!overflowed)
+                resolveBody(Buffer.concat(chunks).toString("utf-8"));
+        });
+        req.on("error", rejectBody);
+    });
+}
+function sendHtml(res, html) {
+    res.writeHead(200, {
+        "Content-Type": "text/html; charset=utf-8",
+        "Cache-Control": "no-store",
+    });
+    res.end(html);
+}
+function sendJson(res, payload) {
+    res.writeHead(200, {
+        "Content-Type": "application/json; charset=utf-8",
+        "Cache-Control": "no-store",
+    });
+    res.end(JSON.stringify(payload));
+}
+/** Decks built from editor content, addressable so a new tab can load them. */
+const decks = new Map();
+let deckSeq = 0;
+/**
+ * Stores a built deck and returns the path that serves it.
+ *
+ * The path stays at the root on purpose: a deck served from a subpath would
+ * resolve `![](diagram.png)` against that subpath instead of the directory
+ * being served, and every local image would 404.
+ */
+function stashDeck(html) {
+    const id = ++deckSeq;
+    decks.set(id, html);
+    // Keep only the handful of most recent builds.
+    for (const key of decks.keys()) {
+        if (decks.size <= 8)
+            break;
+        decks.delete(key);
+    }
+    return `/?deck=${id}`;
+}
+/** A built deck, addressed by `?deck=<id>` so its base URL stays the root. */
+function serveStashedDeck(id, res) {
+    const html = decks.get(parseInt(id, 10));
+    if (!html) {
+        res.writeHead(410, { "Content-Type": "text/plain; charset=utf-8" });
+        res.end("This build has expired. Press present again in the editor.");
+        return;
+    }
+    sendHtml(res, html);
+}
+async function handleEditorRoute(mode, pathname, req, res) {
+    if (pathname === "/__preview" && req.method === "GET") {
+        sendHtml(res, generatePreviewHtml(mode.theme, mode.size, mode.fonts));
+        return true;
+    }
+    if (pathname === "/__parse" && req.method === "POST") {
+        const markdown = await readBody(req);
+        const slides = parseSlides(markdown);
+        sendJson(res, {
+            slides: slides.map((slide, i) => renderSlide(slide, i)),
+            notes: slides.map((slide) => slide.notes ?? ""),
+            title: deckTitle(slides, ""),
+        });
+        return true;
+    }
+    if (pathname === "/__present" && req.method === "POST") {
+        const body = JSON.parse(await readBody(req));
+        const slides = parseSlides(body.markdown ?? "");
+        if (slides.length === 0) {
+            res.writeHead(422, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "no slides" }));
+            return true;
+        }
+        const theme = resolveThemeName(body.theme);
+        const size = resolveSizeName(body.size);
+        const title = deckTitle(slides, body.title?.trim() || "deckrun");
+        // A deck built for printing must not open behind a fullscreen prompt.
+        const forPrint = body.print === true;
+        const path = stashDeck(generateHtml(slides, title, forPrint ? false : mode.fullscreen, theme, size, {
+            head: body.head,
+            body: body.body,
+        }));
+        sendJson(res, { path: forPrint ? `${path}&print=1` : path });
+        return true;
+    }
+    if (pathname === "/__pdf" && req.method === "POST") {
+        const body = JSON.parse(await readBody(req));
+        const slides = parseSlides(body.markdown ?? "");
+        if (slides.length === 0) {
+            res.writeHead(422, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "no slides" }));
+            return true;
+        }
+        const browser = await findBrowser();
+        if (!browser) {
+            // The caller falls back to the print dialog, which prints correctly too.
+            res.writeHead(501, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+                error: "no browser",
+                detail: "No Chrome, Chromium, Edge, or Brave found. Set DECKRUN_BROWSER to one to export PDFs directly.",
+            }));
+            return true;
+        }
+        const theme = resolveThemeName(body.theme);
+        const size = resolveSizeName(body.size);
+        const title = deckTitle(slides, body.title?.trim() || "deckrun");
+        const path = stashDeck(generateHtml(slides, title, false, theme, size, { head: body.head, body: body.body }));
+        try {
+            const pdf = await renderPdfSerial(`${mode.origin}${path}`, browser);
+            const filename = safeFilename(body.title?.trim() || title) + ".pdf";
+            res.writeHead(200, {
+                "Content-Type": "application/pdf",
+                "Content-Length": pdf.length,
+                "Content-Disposition": `attachment; filename="${filename}"`,
+                "Cache-Control": "no-store",
+            });
+            res.end(pdf);
+        }
+        catch (err) {
+            const detail = err instanceof PdfError ? err.message : "rendering failed";
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "render failed", detail }));
+        }
+        return true;
+    }
+    if (pathname === "/__fetch-doc" && req.method === "POST") {
+        const body = JSON.parse(await readBody(req));
+        const raw = (body.url ?? "").trim();
+        let target;
+        try {
+            target = new URL(raw);
+        }
+        catch {
+            res.writeHead(422, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "invalid url" }));
+            return true;
+        }
+        if (target.protocol !== "http:" && target.protocol !== "https:") {
+            res.writeHead(422, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "url must be http or https" }));
+            return true;
+        }
+        let upstream;
+        try {
+            // Fetched server-side, not from the browser, so a page with no
+            // Access-Control-Allow-Origin still loads fine.
+            upstream = await fetch(target, {
+                redirect: "follow",
+                signal: AbortSignal.timeout(15_000),
+                headers: { "User-Agent": "deckrun" },
+            });
+        }
+        catch (err) {
+            res.writeHead(502, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+                error: "fetch failed",
+                detail: err instanceof Error ? err.message : "network error",
+            }));
+            return true;
+        }
+        if (!upstream.ok) {
+            res.writeHead(502, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "fetch failed", detail: `upstream responded ${upstream.status}` }));
+            return true;
+        }
+        const html = await upstream.text();
+        if (html.length > MAX_BODY) {
+            res.writeHead(413, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+                error: "too large",
+                detail: `page is larger than ${Math.round(MAX_BODY / 1024 / 1024)} MB`,
+            }));
+            return true;
+        }
+        if (!html.trim()) {
+            res.writeHead(422, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "empty document" }));
+            return true;
+        }
+        sendJson(res, { html, title: docTitle(html, target.hostname) });
+        return true;
+    }
+    if (pathname === "/__present-doc" && req.method === "POST") {
+        const body = JSON.parse(await readBody(req));
+        const raw = body.html ?? "";
+        if (!raw.trim()) {
+            res.writeHead(422, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "empty document" }));
+            return true;
+        }
+        const theme = resolveThemeName(body.theme);
+        const title = docTitle(raw, body.title?.trim() || "deckrun");
+        const forPrint = body.print === true;
+        const docPath = stashDeck(raw);
+        const wrapperPath = stashDeck(generateDocHtml(docPath, title, forPrint ? false : mode.fullscreen, theme));
+        sendJson(res, { path: forPrint ? `${wrapperPath}&print=1` : wrapperPath, docPath });
+        return true;
+    }
+    if (pathname === "/__pdf-doc" && req.method === "POST") {
+        const body = JSON.parse(await readBody(req));
+        const raw = body.html ?? "";
+        if (!raw.trim()) {
+            res.writeHead(422, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "empty document" }));
+            return true;
+        }
+        const browser = await findBrowser();
+        if (!browser) {
+            res.writeHead(501, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+                error: "no browser",
+                detail: "No Chrome, Chromium, Edge, or Brave found. Set DECKRUN_BROWSER to one to export PDFs directly.",
+            }));
+            return true;
+        }
+        const title = docTitle(raw, body.title?.trim() || "deckrun");
+        // Print the raw doc directly, with no chrome wrapper: its own @page /
+        // print CSS (or Chrome's defaults) governs pagination, and there is no
+        // presenter chrome to strip since there is none in the printed page.
+        const docPath = stashDeck(raw);
+        try {
+            const pdf = await renderPdfSerial(`${mode.origin}${docPath}`, browser);
+            const filename = safeFilename(body.title?.trim() || title) + ".pdf";
+            res.writeHead(200, {
+                "Content-Type": "application/pdf",
+                "Content-Length": pdf.length,
+                "Content-Disposition": `attachment; filename="${filename}"`,
+                "Cache-Control": "no-store",
+            });
+            res.end(pdf);
+        }
+        catch (err) {
+            const detail = err instanceof PdfError ? err.message : "rendering failed";
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "render failed", detail }));
+        }
+        return true;
+    }
+    return false;
+}
+async function serve(mode, baseDir, port) {
+    const server = createServer(async (req, res) => {
+        try {
+            const rawUrl = req.url ?? "/";
+            const [rawPath, rawQuery = ""] = rawUrl.split("?");
+            const pathname = decodeURIComponent(rawPath);
+            const query = new URLSearchParams(rawQuery);
+            if (pathname === "/" || pathname === "/index.html") {
+                const wantsDeck = mode.kind === "editor" && query.get("deck");
+                if (wantsDeck)
+                    serveStashedDeck(wantsDeck, res);
+                else
+                    sendHtml(res, mode.kind === "deck"
+                        ? mode.html
+                        : generateEditorHtml(mode.theme, mode.size, mode.fonts));
+                return;
+            }
+            if (mode.kind === "editor" && (await handleEditorRoute(mode, pathname, req, res))) {
+                return;
+            }
+            // Everything else comes off disk, relative to the working directory.
+            const filePath = resolve(baseDir, pathname.replace(/^\/+/, ""));
+            if (filePath !== baseDir && !filePath.startsWith(baseDir + "/")) {
+                res.writeHead(403);
+                res.end("Forbidden");
+                return;
+            }
+            const data = await readFile(filePath);
+            res.writeHead(200, { "Content-Type": getMime(filePath) });
+            res.end(data);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : "error";
+            if (message === "request body too large") {
+                res.writeHead(413, { "Content-Type": "text/plain", Connection: "close" });
+                res.end(`Deck is larger than ${Math.round(MAX_BODY / 1024 / 1024)} MB.`);
+                req.destroy();
+                return;
+            }
+            if (!res.headersSent)
+                res.writeHead(404, { "Content-Type": "text/plain" });
+            res.end("Not found");
+        }
+    });
+    await new Promise((ready) => server.listen(port, "127.0.0.1", ready));
+    return `http://127.0.0.1:${port}`;
+}
+// ── CLI ───────────────────────────────────────────────────────────────────
+const program = new Command();
+program
+    .name("deckrun")
+    .description("Present a Markdown file in the browser. Run without a file to write one in the built-in editor.")
+    .version(packageVersion(), "-v, --version", "Print the version number")
+    .argument("[file]", "Markdown file to present. Omit it to open the editor.")
+    .option("-p, --port <number>", "Port to serve on", "7890")
+    .option("--no-open", "Do not automatically open the browser")
+    .option("--fullscreen", "Auto-enter fullscreen on first interaction")
+    .option("--theme <name>", "Color theme, by id (see --list-themes)", DEFAULT_THEME)
+    .option("--size <name>", "Type size: s, m, l, or xl", DEFAULT_SIZE)
+    .option("--head-font <name>", "Override the theme's heading face (see --list-fonts)")
+    .option("--body-font <name>", "Override the theme's body face (see --list-fonts)")
+    .option("--list-themes", "Print every theme and exit")
+    .option("--list-sizes", "Print every type size and exit")
+    .option("--list-fonts", "Print every font face and exit")
+    .action(async (file, opts) => {
+    if (opts.listThemes) {
+        for (const line of themeListing())
+            console.log(line);
+        process.exit(0);
+    }
+    if (opts.listSizes) {
+        for (const line of sizeListing())
+            console.log(line);
+        process.exit(0);
+    }
+    if (opts.listFonts) {
+        for (const line of fontListing())
+            console.log(line);
+        process.exit(0);
+    }
+    const named = findTheme(opts.theme);
+    if (!named) {
+        console.error(`deckrun: unknown theme '${opts.theme}'. Run --list-themes to see them all.`);
+        process.exit(1);
+    }
+    const sized = findSize(opts.size);
+    if (!sized) {
+        console.error(`deckrun: unknown size '${opts.size}'. Run --list-sizes to see them all.`);
+        process.exit(1);
+    }
+    // Both face flags are optional; unset means the theme keeps its own.
+    const fonts = { head: null, body: null };
+    for (const [flag, slot] of [
+        ["--head-font", "head"],
+        ["--body-font", "body"],
+    ]) {
+        const raw = slot === "head" ? opts.headFont : opts.bodyFont;
+        if (raw === undefined)
+            continue;
+        const face = findFont(raw);
+        if (!face) {
+            console.error(`deckrun: unknown font '${raw}' for ${flag}. Run --list-fonts to see them all.`);
+            process.exit(1);
+        }
+        fonts[slot] = face;
+    }
+    const theme = named;
+    const size = sized;
+    const fullscreen = !!opts.fullscreen;
+    let mode;
+    let baseDir;
+    if (file) {
+        const absPath = resolve(process.cwd(), file);
+        baseDir = dirname(absPath);
+        const ext = extname(absPath).toLowerCase();
+        if (ext === ".html" || ext === ".htm") {
+            let rawHtml;
+            try {
+                rawHtml = readFileSync(absPath, "utf-8");
+            }
+            catch {
+                console.error(`deckrun: cannot read file '${file}'`);
+                process.exit(1);
+            }
+            if (opts.size !== DEFAULT_SIZE || opts.headFont || opts.bodyFont) {
+                console.error(`${c.dim}deckrun: --size, --head-font, and --body-font only apply to Markdown decks; ignored for an HTML doc.${c.reset}`);
+            }
+            const title = docTitle(rawHtml, basename(absPath, extname(absPath)));
+            mode = {
+                kind: "deck",
+                html: generateDocHtml(`/${basename(absPath)}`, title, fullscreen, theme),
+            };
+            console.log(`${c.dim}presenting ${basename(absPath)} · ${THEMES[theme].label}${c.reset}`);
+        }
+        else {
+            let markdown;
+            try {
+                markdown = readFileSync(absPath, "utf-8");
+            }
+            catch {
+                console.error(`deckrun: cannot read file '${file}'`);
+                process.exit(1);
+            }
+            const slides = parseSlides(markdown);
+            if (slides.length === 0) {
+                console.error("deckrun: no slides found in the file.");
+                process.exit(1);
+            }
+            const title = deckTitle(slides, basename(absPath, extname(absPath)));
+            mode = {
+                kind: "deck",
+                html: generateHtml(slides, title, fullscreen, theme, size, fonts),
+            };
+            const faces = [
+                fonts.head ? `head ${fontName(fonts.head)}` : "",
+                fonts.body ? `body ${fontName(fonts.body)}` : "",
+            ].filter(Boolean).join(" · ");
+            console.log(`${c.dim}${slides.length} slide${slides.length !== 1 ? "s" : ""} from ${basename(absPath)} · ${THEMES[theme].label} · type ${size}${faces ? " · " + faces : ""}${c.reset}`);
+        }
+    }
+    else {
+        baseDir = process.cwd();
+        mode = { kind: "editor", theme, size, fonts, fullscreen };
+    }
+    const port = await findFreePort(parseInt(opts.port, 10));
+    if (mode.kind === "editor")
+        mode.origin = `http://127.0.0.1:${port}`;
+    const url = await serve(mode, baseDir, port);
+    const label = mode.kind === "editor" ? "editor" : "present";
+    console.log(`${c.bold}${c.magenta}${label}${c.reset} ${c.dim}→${c.reset} ${c.cyan}${c.bold}${url}${c.reset}  ${c.dim}(Ctrl+C to stop)${c.reset}`);
+    if (mode.kind === "editor") {
+        console.log(`${c.dim}write on the left, live deck on the right. autosaves to your browser.${c.reset}`);
+        console.log(`${c.dim}Cmd/Ctrl+K inserts anything · Cmd/Ctrl+Shift+L switches theme · Cmd/Ctrl+Enter presents${c.reset}`);
+    }
+    if (opts.open !== false)
+        await open(url);
+    // Keep the process alive until interrupted.
+    await new Promise(() => { });
+});
+program.parse(process.argv);

package/dist/parser.js

@@ -0,0 +1,65 @@
+import { marked } from "marked";
+function parseImageDirective(title) {
+    if (!title)
+        return { position: "inline", opacity: 1 };
+    const t = title.trim().toLowerCase();
+    let position = "inline";
+    if (t.includes("right"))
+        position = "right";
+    else if (t.includes("left"))
+        position = "left";
+    else if (t.includes("bg"))
+        position = "bg";
+    const opacityMatch = t.match(/opacity[=:]?\s*([0-9]*\.?[0-9]+)/);
+    const opacity = opacityMatch
+        ? Math.min(1, Math.max(0, parseFloat(opacityMatch[1])))
+        : 1;
+    return { position, opacity };
+}
+export function parseSlides(markdown) {
+    // Normalize line endings
+    const normalized = markdown.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    // Split on slide separator: "---" on its own line (with optional surrounding blank lines)
+    const rawSlides = normalized.split(/\n[ \t]*---[ \t]*\n/);
+    return rawSlides
+        .map((raw) => raw.trim())
+        .filter((raw) => raw.length > 0)
+        .map((raw) => {
+        const slide = { html: "" };
+        // Extract speaker notes (<!-- notes: ... --> at end)
+        const notesMatch = raw.match(/<!--\s*notes?:\s*([\s\S]*?)\s*-->/i);
+        if (notesMatch) {
+            slide.notes = notesMatch[1].trim();
+        }
+        let processedMd = raw.replace(/<!--\s*notes?:\s*[\s\S]*?\s*-->/gi, "");
+        // Find positioned images via title attribute: ![alt](src "right opacity:0.7")
+        const imgRegex = /!\[([^\]]*)\]\(([^\s)]+)(?:\s+"([^"]*)")?\)/g;
+        const toRemove = [];
+        let match;
+        // Reset lastIndex before use since we're reusing the regex
+        imgRegex.lastIndex = 0;
+        while ((match = imgRegex.exec(raw)) !== null) {
+            const [full, alt, src, titleAttr] = match;
+            const { position, opacity } = parseImageDirective(titleAttr);
+            if (position === "bg") {
+                slide.bgImage = { src, alt, opacity };
+                toRemove.push(full);
+            }
+            else if (position === "right") {
+                slide.rightImage = { src, alt, opacity };
+                toRemove.push(full);
+            }
+            else if (position === "left") {
+                slide.leftImage = { src, alt, opacity };
+                toRemove.push(full);
+            }
+        }
+        for (const item of toRemove) {
+            // Replace only first occurrence (the matched image)
+            processedMd = processedMd.replace(item, "");
+        }
+        // Render remaining markdown to HTML
+        slide.html = marked.parse(processedMd.trim());
+        return slide;
+    });
+}