@litfamily/litmuse 0.1.1 → 0.1.2

package/plugin/lib/capped-fetch.mjs

@@ -0,0 +1,25 @@
+// Bounded response bodies: a fetch that buffers a body reads the stream in pieces
+// and aborts past the limit, so a chunked response without (or lying about)
+// content-length cannot fill the heap before the size check runs.
+export const readCapped = async (response, limit, url) => {
+  const chunks = [];
+  let size = 0;
+  if (response.body && typeof response.body[Symbol.asyncIterator] === 'function') {
+    for await (const chunk of response.body) {
+      size += chunk.length;
+      if (size > limit) {
+        try {
+          await response.body.cancel();
+        } catch {
+          // Already closed by the reader.
+        }
+        throw new Error(`${url} is larger than ${limit} bytes`);
+      }
+      chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+  }
+  const whole = Buffer.from(await response.arrayBuffer());
+  if (whole.length > limit) throw new Error(`${url} is larger than ${limit} bytes`);
+  return whole;
+};

package/plugin/lib/pinned-fetch.mjs

@@ -0,0 +1,79 @@
+// Pinned HTTPS: resolve once for the hop check, then connect only to the approved
+// address, so a name that answers again with a private address (DNS rebinding) cannot
+// move the connection. TLS still verifies the certificate for the name.
+import { isIP, isIPv4, isIPv6 } from 'node:net';
+import { request as httpsRequest } from 'node:https';
+import { Readable } from 'node:stream';
+
+const privateV4 = (ip) => {
+  const [a, b] = ip.split('.').map(Number);
+  return a === 0 || a === 10 || a === 127 || a >= 224 || (a === 100 && b >= 64 && b <= 127) || (a === 169 && b === 254)
+    || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168) || (a === 198 && (b === 18 || b === 19));
+};
+
+// Loopback, link-local, private, CGNAT, benchmark, multicast and cloud-metadata ranges,
+// plus IPv4-mapped IPv6 forms of the same. Anything else, including bare names, is public.
+export const isPrivateAddress = (address) => {
+  const ip = String(address).replace(/^\[|\]$/gu, '').toLowerCase();
+  if (isIPv4(ip)) return privateV4(ip);
+  if (!isIPv6(ip)) return false;
+  const mapped = /^(?:0*:)*:?ffff:(?:(\d+\.\d+\.\d+\.\d+)|([0-9a-f]{1,4}):([0-9a-f]{1,4}))$/u.exec(ip);
+  if (mapped) {
+    if (mapped[1]) return privateV4(mapped[1]);
+    const [high, low] = [mapped[2], mapped[3]].map((part) => Number.parseInt(part, 16));
+    return privateV4(`${high >> 8}.${high & 255}.${low >> 8}.${low & 255}`);
+  }
+  return ip === '::' || ip === '::1' || /^f[cd]/u.test(ip) || /^fe[89ab]/u.test(ip) || /^ff/u.test(ip);
+};
+
+// One redirect hop: https only, no local names or addresses, and names must resolve to
+// at least one address with none private. Returns the href with the approved address, so
+// the connect below cannot be moved by a second, private answer.
+export const checkHop = async (href, lookup, httpsNote = 'fetch https only') => {
+  let url;
+  try {
+    url = new URL(href);
+  } catch {
+    throw new Error(`refusing ${href}: not a URL`);
+  }
+  if (url.protocol !== 'https:') throw new Error(`refusing ${url.protocol} ${href}: ${httpsNote}`);
+  const host = url.hostname.replace(/^\[|\]$/gu, '');
+  if (host === 'localhost' || host.endsWith('.localhost') || isPrivateAddress(host)) {
+    throw new Error(`refusing ${href}: a loopback, link-local or private host`);
+  }
+  if (isIP(host)) return { href: url.href, address: host, family: isIP(host) };
+  if (!lookup) return { href: url.href, address: null, family: 0 };
+  const addresses = await lookup(host, { all: true });
+  if (!Array.isArray(addresses) || addresses.length === 0) throw new Error(`refusing ${href}: ${host} does not resolve`);
+  if (addresses.some(({ address }) => isPrivateAddress(address))) {
+    throw new Error(`refusing ${href}: ${host} resolves to a private address`);
+  }
+  return { href: url.href, address: addresses[0].address, family: addresses[0].family };
+};
+
+// node:https with a lookup that answers only with the approved address, read back as a
+// Response. `request` is injectable for tests; pass a real name and the TLS certificate
+// is still verified for it.
+export const pinnedSend = (request = httpsRequest) => (href, { headers, signal }, { address, family }) => new Promise((resolveResponse, reject) => {
+  const pin = (host, options, callback) => {
+    if (typeof options === 'function') { options(null, address, family); return; }
+    if (options && options.all) callback(null, [{ address, family }]);
+    else callback(null, address, family);
+  };
+  const req = request(href, { headers, signal, lookup: pin }, (res) => {
+    const answer = new Headers();
+    for (const [name, value] of Object.entries(res.headers ?? {})) {
+      for (const item of [value].flat()) if (item !== undefined) answer.append(name, String(item));
+    }
+    const empty = [204, 205, 304].includes(res.statusCode);
+    if (empty && typeof res.resume === 'function') res.resume();
+    try {
+      resolveResponse(new Response(empty ? null : Readable.toWeb(res), { status: res.statusCode, headers: answer }));
+    } catch (error) {
+      if (typeof res.destroy === 'function') res.destroy();
+      reject(error);
+    }
+  });
+  req.on('error', reject);
+  req.end();
+});

package/plugin/lib/plan-task-rows.mjs

@@ -0,0 +1,32 @@
+/** Return source lines that are outside Markdown code fences, preserving line indexes. */
+export const planLinesOutsideFences = (text) => {
+  const visible = [];
+  let fence = null;
+  const lines = text.split(/\r?\n/u);
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    const fenceMatch = /^ {0,3}(`{3,}|~{3,})(.*)$/u.exec(line);
+    if (!fence && fenceMatch) {
+      fence = { marker: fenceMatch[1][0], length: fenceMatch[1].length };
+      continue;
+    }
+    if (
+      fence
+      && fenceMatch
+      && fenceMatch[1][0] === fence.marker
+      && fenceMatch[1].length >= fence.length
+      && fenceMatch[2].trim() === ""
+    ) {
+      fence = null;
+      continue;
+    }
+    if (!fence) visible.push({ line, index });
+  }
+  return visible;
+};
+
+/** Parse the exact column-zero checkbox grammar consumed by start-work. */
+export const parsePlanTaskRows = (text) => planLinesOutsideFences(text).flatMap(({ line, index }) => {
+  const match = /^- \[([ xX])\]\s+(.+?)\s*$/u.exec(line);
+  return match ? [{ checked: match[1].toLowerCase() === "x", text: match[2], line, index }] : [];
+});

package/plugin/lib/render_pages.py

@@ -2,7 +2,9 @@
 """Render a .pptx, .docx or .pdf to PNG pages so a person (or the model) can look at it.
 
 LibreOffice (soffice) converts Office files to PDF in a private profile directory,
-so parallel runs never share a lock; PyMuPDF rasterises the PDF pages. A PDF input
+so parallel runs never share a lock; PyMuPDF rasterises the PDF pages. Fonts a .pptx
+embeds as plain font files are placed in that profile's font folder first, so the pages
+show the faces PowerPoint shows even where the font is not installed. A PDF input
 skips the conversion. Without soffice an Office file cannot be rendered: the script
 prints SKIP with the reason and exits 0, and the caller must say that the visual
 pass did not happen.
@@ -21,9 +23,34 @@ import shutil
 import subprocess
 import sys
 import tempfile
+import zipfile
 from pathlib import Path
 
 
+def profile_fonts(source: Path, profile: Path) -> list[Path]:
+    """Copy the plain font files a .pptx embeds (ppt/fonts/*.fntdata) into the profile's font folder."""
+    if source.suffix.lower() != ".pptx":
+        return []
+    placed = []
+    try:
+        with zipfile.ZipFile(source) as z:
+            for name in z.namelist():
+                if not (name.startswith("ppt/fonts/") and name.endswith(".fntdata")):
+                    continue
+                data = z.read(name)
+                # Only a TrueType or OpenType file; an obfuscated or EOT part is left to the renderer.
+                kind = ".otf" if data[:4] == b"OTTO" else ".ttf" if data[:4] in (b"\x00\x01\x00\x00", b"true") else None
+                if not kind:
+                    continue
+                target = profile / "user" / "fonts" / (Path(name).stem + kind)
+                target.parent.mkdir(parents=True, exist_ok=True)
+                target.write_bytes(data)
+                placed.append(target)
+    except zipfile.BadZipFile:
+        return []
+    return placed
+
+
 def to_pdf(source: Path, out_dir: Path) -> tuple[Path | None, str]:
     if source.suffix.lower() == ".pdf":
         return source, "input is already PDF"
@@ -31,6 +58,7 @@ def to_pdf(source: Path, out_dir: Path) -> tuple[Path | None, str]:
     if not soffice:
         return None, "LibreOffice (soffice) is not on PATH"
     with tempfile.TemporaryDirectory(prefix="litmuse-soffice-") as profile:
+        profile_fonts(source, Path(profile))
         result = subprocess.run(
             [
                 soffice,