mdv-live 0.5.4 → 0.5.8

package/src/static/styles.css

@@ -241,6 +241,40 @@ body {
 
 .toolbar-spacer { flex: 1; }
 
+.pdf-style-panel {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 8px 16px;
+    border-bottom: 1px solid var(--border);
+    background: var(--bg-secondary);
+}
+
+.pdf-style-panel label {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    min-width: 0;
+    color: var(--text-secondary);
+    font-size: 12px;
+}
+
+.pdf-style-panel input {
+    width: min(34vw, 360px);
+    min-width: 160px;
+    padding: 6px 8px;
+    background: var(--bg-primary);
+    border: 1px solid var(--border);
+    border-radius: 6px;
+    color: var(--text-primary);
+    font-size: 12px;
+}
+
+.pdf-style-panel input:focus {
+    border-color: var(--accent);
+    outline: none;
+}
+
 .status {
     display: flex;
     align-items: center;

package/src/styles/index.js

@@ -0,0 +1,90 @@
+/**
+ * PDF style preset system.
+ * Built-in styles are intentionally minimal; custom PDF styling is done by
+ * passing a CSS file path to the convert command.
+ */
+
+import fs from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+
+const require = createRequire(import.meta.url);
+const HIGHLIGHT_STYLES_DIR = path.resolve(path.dirname(require.resolve('highlight.js')), '..', 'styles');
+
+const BASE_PDF_OPTIONS = {
+  format: 'A4',
+  margin: { top: '20mm', right: '20mm', bottom: '20mm', left: '20mm' },
+};
+
+/**
+ * @typedef {object} StyleConfig
+ * @property {string | null} stylesheet - Single stylesheet path for custom CSS.
+ * @property {string[]} [stylesheets] - Ordered stylesheet paths injected before md-to-pdf inline CSS.
+ * @property {object} pdfOptions - Puppeteer PDF options passed to md-to-pdf.
+ * @property {string} [highlightStyle] - highlight.js theme name used by md-to-pdf.
+ * @property {string} [css] - Inline CSS injected after md-to-pdf stylesheets.
+ */
+
+/**
+ * @typedef {Record<string, unknown>} PdfOptions
+ */
+
+/** @type {Record<string, StyleConfig>} */
+export const PRESETS = {
+  default: {
+    stylesheet: null,
+    pdfOptions: BASE_PDF_OPTIONS,
+  },
+};
+
+/**
+ * Resolve a style argument to a StyleConfig.
+ * Accepts a built-in preset name or a path to a custom CSS file.
+ *
+ * @param {string | undefined} styleArg - Preset name or CSS file path
+ * @returns {Promise<StyleConfig>}
+ * @throws {Error} If a CSS file path is given but does not exist
+ */
+export async function resolveStyle(styleArg) {
+  if (!styleArg) return PRESETS.default;
+
+  if (Object.hasOwn(PRESETS, styleArg)) return PRESETS[styleArg];
+
+  // Treat as a custom CSS file path
+  const cssPath = path.resolve(styleArg);
+  await fs.access(cssPath);
+  return {
+    stylesheet: cssPath,
+    stylesheets: [
+      path.join(HIGHLIGHT_STYLES_DIR, 'atom-one-dark.css'),
+      cssPath,
+    ],
+    highlightStyle: 'atom-one-dark',
+    pdfOptions: BASE_PDF_OPTIONS,
+  };
+}
+
+/**
+ * Resolve a JSON file containing Puppeteer PDF options.
+ *
+ * @param {string | undefined} pdfOptionsPath - JSON file path.
+ * @param {object} baseOptions - Base options to merge into.
+ * @returns {Promise<object>} Merged PDF options.
+ * @throws {Error} If the file does not contain a JSON object.
+ */
+export async function resolvePdfOptions(pdfOptionsPath, baseOptions = BASE_PDF_OPTIONS) {
+  if (!pdfOptionsPath) return baseOptions;
+
+  const resolvedPath = path.resolve(pdfOptionsPath);
+  const rawOptions = await fs.readFile(resolvedPath, 'utf-8');
+  const parsedOptions = JSON.parse(rawOptions);
+
+  if (!parsedOptions || typeof parsedOptions !== 'object' || Array.isArray(parsedOptions)) {
+    throw new Error(`PDF options must be a JSON object: ${pdfOptionsPath}`);
+  }
+
+  return {
+    ...baseOptions,
+    ...parsedOptions,
+  };
+}

package/src/styles/report.example.css

@@ -0,0 +1,201 @@
+/* Report style — matches blue-accented business document layout */
+
+:root {
+  --blue: #1a6496;
+  --blue-light: #2980b9;
+  --border-strong: 2px solid #1a6496;
+  --border-light: 1px solid #ccc;
+  --text: #222;
+  --muted: #555;
+  --table-header-bg: #f0f4f8;
+}
+
+/* ── Base ────────────────────────────────────────────────── */
+
+body {
+  font-family: 'Noto Sans CJK JP', 'Noto Sans JP', sans-serif;
+  font-size: 10.5pt;
+  line-height: 1.75;
+  color: var(--text);
+}
+
+/* ── Headings ────────────────────────────────────────────── */
+
+/* Title page: the very first H1 */
+h1:first-of-type {
+  font-size: 2.4em;
+  font-weight: 700;
+  color: var(--blue);
+  text-align: center;
+  border-bottom: none;
+  margin-top: 5em;
+  margin-bottom: 0.3em;
+}
+
+/* Section H1s (after the first) */
+h1 {
+  font-size: 1.5em;
+  font-weight: 700;
+  color: var(--blue);
+  border-bottom: var(--border-strong);
+  padding-bottom: 4px;
+  margin-top: 2em;
+  margin-bottom: 0.8em;
+}
+
+h2 {
+  font-size: 1.25em;
+  font-weight: 700;
+  color: var(--blue);
+  border-bottom: var(--border-light);
+  padding-bottom: 3px;
+  margin-top: 1.8em;
+  margin-bottom: 0.6em;
+}
+
+h3 {
+  font-size: 1.05em;
+  font-weight: 700;
+  color: var(--blue);
+  margin-top: 1.4em;
+  margin-bottom: 0.4em;
+}
+
+h4, h5, h6 {
+  color: var(--blue);
+  margin-top: 1em;
+  margin-bottom: 0.3em;
+}
+
+/* ── Body text ───────────────────────────────────────────── */
+
+p {
+  margin: 0.5em 0;
+  padding-left: 1em;
+  text-indent: 1em;
+}
+
+/* Subtitle / date line (paragraph immediately after first H1) */
+h1:first-of-type + p {
+  text-align: center;
+  color: var(--muted);
+  font-size: 0.95em;
+  padding-left: 0;
+  text-indent: 0;
+}
+
+li p,
+blockquote p,
+td p,
+th p {
+  padding-left: 0;
+  text-indent: 0;
+}
+
+/* ── Horizontal rule ─────────────────────────────────────── */
+
+hr {
+  border: none;
+  break-after: page;
+  margin: 0;
+}
+
+/* ── Links ───────────────────────────────────────────────── */
+
+a {
+  color: var(--blue-light);
+  text-decoration: underline;
+}
+
+/* ── Tables ──────────────────────────────────────────────── */
+
+table {
+  border-collapse: collapse;
+  width: 100%;
+  margin: 1em 0;
+  font-size: 9.5pt;
+}
+
+th {
+  background: var(--table-header-bg);
+  border: 1px solid #aaa;
+  padding: 6px 10px;
+  font-weight: 700;
+  text-align: center;
+}
+
+td {
+  border: 1px solid #aaa;
+  padding: 6px 10px;
+  vertical-align: top;
+}
+
+/* ── Lists ───────────────────────────────────────────────── */
+
+ul, ol {
+  margin: 0.4em 0 0.4em 1em;
+  padding-left: 1.4em;
+}
+
+li {
+  margin: 0.2em 0;
+}
+
+/* ── Code ────────────────────────────────────────────────── */
+
+pre {
+  background: #282c34;
+  color: #d7dae0;
+  font-family: 'Noto Mono', monospace;
+  font-size: 8.5pt;
+  padding: 0.8em 1em;
+  line-height: 1.5;
+  overflow: auto;
+  border-radius: 4px;
+}
+
+pre code,
+pre code.hljs,
+.hljs {
+  background: #282c34;
+  color: #d7dae0;
+  font-family: 'Noto Mono', monospace;
+  font-size: 8.5pt;
+}
+
+code {
+  border-radius: 2px;
+  padding: 1px 5px;
+}
+
+pre code.hljs .hljs-section,
+pre code.hljs .hljs-title {
+  color: #61afef;
+}
+
+pre code.hljs .hljs-tag,
+pre code.hljs .hljs-name,
+pre code.hljs .hljs-selector-tag {
+  color: #e06c75;
+}
+
+pre code.hljs .hljs-string,
+pre code.hljs .hljs-attr,
+pre code.hljs .hljs-attribute {
+  color: #98c379;
+}
+
+pre code.hljs .hljs-comment,
+pre code.hljs .hljs-quote {
+  color: #8f98a8;
+  font-style: normal;
+}
+
+/* ── Blockquote ──────────────────────────────────────────── */
+
+blockquote {
+  border-left: 3px solid var(--blue);
+  margin: 0.8em 0 0.8em 1em;
+  padding: 0.4em 0.8em;
+  color: var(--muted);
+}

package/src/styles/report.pdf-options.example.json

@@ -0,0 +1,10 @@
+{
+  "format": "A4",
+  "margin": {
+    "top": "28mm",
+    "right": "20mm",
+    "bottom": "22mm",
+    "left": "20mm"
+  },
+  "printBackground": true
+}

package/src/utils/atomicWrite.js

@@ -0,0 +1,159 @@
+/**
+ * Atomic file write with permission preservation, EXDEV fallback, and
+ * O_EXCL temp creation.
+ *
+ * Caller passes `originalStat` taken from an earlier `fd.stat()` (so the
+ * permissions on the new content match the file's prior mode/uid/gid).
+ */
+
+import * as fs from 'node:fs/promises';
+import { constants as fsConstants } from 'node:fs';
+import * as crypto from 'node:crypto';
+import * as path from 'node:path';
+import { mkError } from './errors.js';
+
+const TMP_PREFIX = '.~mdvtmp.';
+const PART_PREFIX = '.~mdvpart.';
+const SWEEP_AGE_MS = 60 * 60 * 1000; // 1 hour
+
+function isWritable(stat) {
+  // Owner-write or group-write (group/world write would already need elevated
+  // perms to even reach here). Be generous: any write bit set.
+  return (stat.mode & 0o222) !== 0;
+}
+
+/**
+ * Atomically write `content` to `fullPath`.
+ *
+ * @param {string} fullPath  absolute path to overwrite
+ * @param {string} content   utf-8 string contents
+ * @param {fs.Stats|null} originalStat  stat from prior fd.stat(); used to
+ *   restore mode/uid/gid. Pass null for new files.
+ */
+export async function atomicWrite(fullPath, content, originalStat) {
+  if (originalStat && !isWritable(originalStat)) {
+    throw mkError('READONLY', 'file is not writable');
+  }
+
+  const dir = path.dirname(fullPath);
+  const base = path.basename(fullPath);
+  const tmpPath = path.join(
+    dir,
+    `${TMP_PREFIX}${process.pid}.${crypto.randomBytes(6).toString('hex')}.${base}`
+  );
+
+  let tmpHandle = null;
+  let tmpExists = false;
+  try {
+    // O_EXCL: fail loudly if the random name happens to collide.
+    tmpHandle = await fs.open(
+      tmpPath,
+      fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL,
+      0o600
+    );
+    tmpExists = true;
+    await tmpHandle.writeFile(content, 'utf-8');
+
+    // Restore permissions. Allow EPERM/ENOTSUP only — other failures
+    // (ENOSPC, EROFS, etc.) must surface as WRITE_FAILED.
+    if (originalStat) {
+      try {
+        await tmpHandle.chmod(originalStat.mode & 0o7777);
+      } catch (e) {
+        if (e.code !== 'EPERM' && e.code !== 'ENOTSUP') throw e;
+      }
+      try {
+        await tmpHandle.chown(originalStat.uid, originalStat.gid);
+      } catch (e) {
+        if (e.code !== 'EPERM') throw e;
+      }
+    }
+
+    await tmpHandle.close();
+    tmpHandle = null;
+
+    // Atomic replace. Try rename first; fall back to two-step on EXDEV.
+    try {
+      await fs.rename(tmpPath, fullPath);
+      tmpExists = false;
+    } catch (err) {
+      if (err.code !== 'EXDEV') throw err;
+      const partPath = path.join(
+        dir,
+        `${PART_PREFIX}${crypto.randomBytes(6).toString('hex')}.${base}`
+      );
+      try {
+        await fs.copyFile(tmpPath, partPath);
+        await fs.rename(partPath, fullPath);
+      } catch (err2) {
+        try { await fs.unlink(partPath); } catch {}
+        throw err2;
+      }
+      // tmpPath is still around; cleaned up in finally.
+    }
+  } catch (err) {
+    if (err && err.code && !['READONLY', 'EPERM'].includes(err.code)) {
+      // Wrap unknown failures as WRITE_FAILED so callers get a stable code.
+      const wrapped = mkError('WRITE_FAILED', err.message || String(err));
+      wrapped.cause = err;
+      throw wrapped;
+    }
+    throw err;
+  } finally {
+    if (tmpHandle) {
+      try { await tmpHandle.close(); } catch {}
+    }
+    if (tmpExists) {
+      try { await fs.unlink(tmpPath); } catch {}
+    }
+  }
+}
+
+/**
+ * Sweep stale temp files left by previous (crashed) writes.
+ * Only removes files we own (uid match) and that are older than SWEEP_AGE_MS.
+ */
+export async function sweepStaleTemps(rootDir) {
+  let myUid;
+  try {
+    myUid = process.getuid();
+  } catch {
+    // Windows lacks getuid; sweep is best-effort there.
+    myUid = null;
+  }
+  await sweepDir(rootDir, myUid);
+}
+
+async function sweepDir(dir, myUid) {
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      // Cap recursion depth implicitly via existing watcher depth elsewhere;
+      // sweep here is shallow at rootDir to limit scan cost.
+      // Skip recursion to keep startup fast — callers can opt in if needed.
+      continue;
+    }
+    if (
+      !entry.name.startsWith(TMP_PREFIX) &&
+      !entry.name.startsWith(PART_PREFIX)
+    ) {
+      continue;
+    }
+    let st;
+    try {
+      st = await fs.lstat(full);
+    } catch {
+      continue;
+    }
+    const ageMs = Date.now() - st.mtimeMs;
+    if (ageMs < SWEEP_AGE_MS) continue;
+    if (myUid !== null && st.uid !== myUid) continue;
+    try { await fs.unlink(full); } catch {}
+  }
+}

package/src/utils/errors.js

@@ -0,0 +1,50 @@
+/**
+ * Single source of truth for application error codes, HTTP status mapping,
+ * and error construction.
+ *
+ * Replaces the four duplicated `mkError` helpers and the scattered
+ * status-code logic that the audit flagged.
+ */
+
+export const ERROR_STATUS = Object.freeze({
+  PATH_INVALID: 403,
+  NOT_FOUND: 404,
+  NOT_MARP: 400,
+  OUT_OF_RANGE: 400,
+  INVALID_NOTE: 400,
+  MULTI_NOTE_READONLY: 409,
+  STALE: 412,
+  IF_MATCH_REQUIRED: 428,
+  PAYLOAD_TOO_LARGE: 413,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  ORIGIN_REJECTED: 403,
+  READONLY: 403,
+  NOT_PARSEABLE: 500,
+  WRITE_FAILED: 500,
+  READ_FAILED: 500,
+  // client-only codes (do not produce HTTP responses)
+  NETWORK_ERROR: 0,
+  DEGRADED: 0
+});
+
+/** Construct a coded Error with optional `cause`. */
+export function mkError(code, message, opts = {}) {
+  const err = new Error(message || code);
+  err.code = code;
+  if (opts.cause) err.cause = opts.cause;
+  if (opts.currentEtag) err.currentEtag = opts.currentEtag;
+  return err;
+}
+
+/** Send an Error as a normalized JSON response. Stack traces are NOT leaked. */
+export function sendError(res, err) {
+  const code = err && err.code in ERROR_STATUS ? err.code : 'WRITE_FAILED';
+  const status = ERROR_STATUS[code] || 500;
+  const payload = {
+    ok: false,
+    code,
+    error: (err && err.message) || code
+  };
+  if (err && err.currentEtag) payload.currentEtag = err.currentEtag;
+  return res.status(status).json(payload);
+}

package/src/utils/etag.js

@@ -0,0 +1,11 @@
+/**
+ * Single source of truth for the file-content ETag format.
+ * `sha256:<hex>` over UTF-8 bytes of the source. Replaces the duplicated
+ * helpers previously embedded in rendering/index.js and api/marpNote.js.
+ */
+
+import crypto from 'node:crypto';
+
+export function makeEtag(rawSource) {
+  return 'sha256:' + crypto.createHash('sha256').update(rawSource).digest('hex');
+}

package/src/utils/lineMath.js

@@ -0,0 +1,86 @@
+/**
+ * 行↔バイト (JS string index) 変換ヘルパ。
+ *
+ * 規約:
+ *  - BOM (U+FEFF) は rawSource[0] にそのまま残す。lineStarts[0] = 0。
+ *  - 改行は LF / CRLF / CR の混在を検出。最頻種を `lineEnding` として記録し、
+ *    新規挿入行のみその改行種別を使う。既存改行は触らない。
+ *  - lineStarts[i] = i 行目（0-origin）の先頭の JS string index。
+ *  - markdown-it / marpit の token.map と整合: countLines が `t.map[1]` の
+ *    最大値と一致する。
+ */
+
+/** Compute the string index of the start of each line (0-origin). */
+export function computeLineStarts(source) {
+  const starts = [0];
+  for (let i = 0; i < source.length; i++) {
+    const ch = source[i];
+    if (ch === '\n') {
+      starts.push(i + 1);
+    } else if (ch === '\r') {
+      // Treat \r and \r\n as a single line break.
+      const next = i + 1;
+      if (next < source.length && source[next] === '\n') {
+        starts.push(next + 1);
+        i++;
+      } else {
+        starts.push(next);
+      }
+    }
+  }
+  return starts;
+}
+
+/**
+ * Inspect raw source for line-ending statistics, BOM, EOF newline.
+ * @param {string} source
+ * @returns {{
+ *   lineEnding: '\n' | '\r\n' | '\r',
+ *   hasBom: boolean,
+ *   endsWithNewline: boolean,
+ *   lineStarts: number[]
+ * }}
+ */
+export function analyseSource(source) {
+  const hasBom = source.charCodeAt(0) === 0xFEFF;
+  const crlf = (source.match(/\r\n/g) || []).length;
+  const lf = (source.match(/(?<!\r)\n/g) || []).length;
+  const cr = (source.match(/\r(?!\n)/g) || []).length;
+  let lineEnding = '\n';
+  if (crlf > lf && crlf > cr) lineEnding = '\r\n';
+  else if (cr > lf && cr > crlf) lineEnding = '\r';
+  const endsWithNewline = /(?:\r\n|\r|\n)$/.test(source);
+  const lineStarts = computeLineStarts(source);
+  return { lineEnding, hasBom, endsWithNewline, lineStarts };
+}
+
+/**
+ * Convert a line index to a string index. Throws if line is out of range.
+ * @param {number[]} lineStarts
+ * @param {number} line  0-origin line number
+ * @returns {number}
+ */
+export function lineToOffset(lineStarts, line) {
+  if (line < 0) throw new Error(`line out of range: ${line}`);
+  if (line < lineStarts.length) return lineStarts[line];
+  // For one-past-the-end (== total lines), return source length.
+  // Caller (e.g. last slide endLine) should pass `source.length` separately.
+  throw new Error(`line out of range: ${line} (max ${lineStarts.length - 1})`);
+}
+
+/**
+ * Convert [startLine, endLine) half-open line range to [startOffset, endOffset).
+ * `endLine` may equal `totalLines` to mean "to end of source".
+ *
+ * @param {number[]} lineStarts
+ * @param {number} totalLines  number of lines in the source
+ * @param {number} sourceLength
+ * @param {number} startLine
+ * @param {number} endLine
+ * @returns {{startOffset: number, endOffset: number}}
+ */
+export function lineRangeToOffsets(lineStarts, totalLines, sourceLength, startLine, endLine) {
+  const startOffset = lineToOffset(lineStarts, startLine);
+  const endOffset = endLine >= totalLines ? sourceLength : lineToOffset(lineStarts, endLine);
+  return { startOffset, endOffset };
+}