@karmaniverous/jeeves-server 3.5.2 → 3.6.1

package/dist/src/routes/api/export.test.js

@@ -0,0 +1,46 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+vi.mock('@karmaniverous/jeeves', () => ({
+    getBindAddress: vi.fn(),
+}));
+const { getBindAddress } = await import('@karmaniverous/jeeves');
+const mockedGetBindAddress = vi.mocked(getBindAddress);
+/**
+ * Replicate the bind-address resolution logic from export.ts:
+ * 0.0.0.0 (all interfaces) is not a valid request target, so fall back to loopback.
+ */
+function resolveRenderHost(bindAddr) {
+    return bindAddr === '0.0.0.0' ? '127.0.0.1' : bindAddr;
+}
+describe('export render host resolution', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('resolves 0.0.0.0 to 127.0.0.1 for Chrome render URL', () => {
+        mockedGetBindAddress.mockReturnValue('0.0.0.0');
+        const bindAddr = getBindAddress('server');
+        const renderHost = resolveRenderHost(bindAddr);
+        expect(renderHost).toBe('127.0.0.1');
+    });
+    it('preserves a specific bind address for Chrome render URL', () => {
+        mockedGetBindAddress.mockReturnValue('192.168.1.5');
+        const bindAddr = getBindAddress('server');
+        const renderHost = resolveRenderHost(bindAddr);
+        expect(renderHost).toBe('192.168.1.5');
+    });
+    it('preserves loopback address as-is', () => {
+        mockedGetBindAddress.mockReturnValue('127.0.0.1');
+        const bindAddr = getBindAddress('server');
+        const renderHost = resolveRenderHost(bindAddr);
+        expect(renderHost).toBe('127.0.0.1');
+    });
+    it('constructs a valid export URL with resolved host and port', () => {
+        mockedGetBindAddress.mockReturnValue('0.0.0.0');
+        const bindAddr = getBindAddress('server');
+        const renderHost = resolveRenderHost(bindAddr);
+        const port = 1934;
+        const reqPath = 'c/docs/readme.md';
+        const key = 'test-key';
+        const exportUrl = `http://${renderHost}:${String(port)}/browse/${reqPath}?key=${key}&render_diagrams=1&plain_code=1`;
+        expect(exportUrl).toBe('http://127.0.0.1:1934/browse/c/docs/readme.md?key=test-key&render_diagrams=1&plain_code=1');
+    });
+});

package/dist/src/routes/api/fileContent.js

@@ -5,7 +5,9 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
+import { getServiceUrl } from '@karmaniverous/jeeves';
 import { getConfig } from '../../config/index.js';
+import { csvToHtmlTable } from '../../services/csv.js';
 import { rewriteLinksForDeepShare } from '../../services/deepShareLinks.js';
 import { getOrRenderDiagram } from '../../services/diagramCache.js';
 import { renderEmbeddedDiagrams, setDiagramContext, } from '../../services/embeddedDiagrams.js';
@@ -102,6 +104,28 @@ export const fileContentRoutes = async (fastify) => {
                 isInsider,
             });
         }
+        // CSV
+        if (ext === '.csv') {
+            const content = fs.readFileSync(resolved, 'utf8');
+            if (rawOnly) {
+                return reply.send({
+                    type: 'text',
+                    content,
+                    fileName,
+                    breadcrumbs,
+                    isInsider,
+                });
+            }
+            const html = csvToHtmlTable(content);
+            return reply.send({
+                type: 'csv',
+                content,
+                html,
+                fileName,
+                breadcrumbs,
+                isInsider,
+            });
+        }
         // Text files
         const buffer = fs.readFileSync(resolved);
         if (looksLikeText(buffer)) {
@@ -184,11 +208,9 @@ export const fileContentRoutes = async (fastify) => {
  * Returns null if watcher is not configured, unreachable, or no rules match.
  */
 async function tryWatcherRender(fsPath) {
-    const config = getConfig();
-    if (!config.watcherUrl)
-        return null;
+    const watcherUrl = getServiceUrl('watcher');
     try {
-        const res = await fetch(`${config.watcherUrl}/render`, {
+        const res = await fetch(`${watcherUrl}/render`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({

package/dist/src/routes/api/runner.js

@@ -4,10 +4,9 @@
  * All routes require insider auth. The runner only listens on localhost,
  * so jeeves-server acts as an authenticated gateway.
  */
-import { getConfig } from '../../config/index.js';
-const DEFAULT_RUNNER_URL = 'http://127.0.0.1:3100';
+import { getServiceUrl } from '@karmaniverous/jeeves';
 function getRunnerUrl() {
-    return getConfig().runnerUrl ?? DEFAULT_RUNNER_URL;
+    return getServiceUrl('runner');
 }
 /** Proxy a request to the runner and send the response via reply. */
 async function proxyToRunner(reply, path, method = 'GET') {

package/dist/src/routes/api/runner.test.js

@@ -0,0 +1,29 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+vi.mock('@karmaniverous/jeeves', () => ({
+    getServiceUrl: vi.fn(),
+}));
+const { getServiceUrl } = await import('@karmaniverous/jeeves');
+const mockedGetServiceUrl = vi.mocked(getServiceUrl);
+describe('runner URL resolution', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('resolves runner URL via core getServiceUrl', () => {
+        mockedGetServiceUrl.mockReturnValue('http://127.0.0.1:1937');
+        const url = getServiceUrl('runner');
+        expect(url).toBe('http://127.0.0.1:1937');
+        expect(mockedGetServiceUrl).toHaveBeenCalledWith('runner');
+    });
+    it('uses the URL from core, not a hardcoded default', () => {
+        mockedGetServiceUrl.mockReturnValue('http://10.0.0.5:9999');
+        const url = getServiceUrl('runner');
+        expect(url).toBe('http://10.0.0.5:9999');
+    });
+    it('constructs proxy paths correctly from the resolved URL', () => {
+        mockedGetServiceUrl.mockReturnValue('http://127.0.0.1:1937');
+        const base = getServiceUrl('runner');
+        const jobId = 'my-job';
+        expect(`${base}/jobs/${encodeURIComponent(jobId)}`).toBe('http://127.0.0.1:1937/jobs/my-job');
+        expect(`${base}/jobs/${encodeURIComponent(jobId)}/runs?limit=20`).toBe('http://127.0.0.1:1937/jobs/my-job/runs?limit=20');
+    });
+});

package/dist/src/routes/api/search.js

@@ -7,6 +7,7 @@
  * @packageDocumentation
  */
 import { stat } from 'node:fs/promises';
+import { getServiceUrl } from '@karmaniverous/jeeves';
 import picomatch from 'picomatch';
 import { getConfig } from '../../config/index.js';
 import { fsPathToUrl, getRoots, urlPathToFs } from '../../util/platform.js';
@@ -33,9 +34,7 @@ export const searchRoutes = async (fastify) => {
             return reply.code(403).send({ error: 'Insider access required' });
         }
         const config = getConfig();
-        if (!config.watcherUrl) {
-            return reply.code(501).send({ error: 'Search not configured' });
-        }
+        const watcherUrl = getServiceUrl('watcher');
         const { query, limit = 20, filter } = request.body;
         if (!query || typeof query !== 'string') {
             return reply.code(400).send({ error: 'query is required' });
@@ -45,7 +44,7 @@ export const searchRoutes = async (fastify) => {
         // Over-fetch to account for scope filtering
         const fetchLimit = Math.min(limit * 5, 200);
         try {
-            const watcherRes = await fetch(`${config.watcherUrl}/search`, {
+            const watcherRes = await fetch(`${watcherUrl}/search`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify({ query, limit: fetchLimit, filter }),
@@ -177,10 +176,7 @@ export const searchRoutes = async (fastify) => {
         if (request.accessMode !== 'insider') {
             return reply.code(403).send({ error: 'Insider access required' });
         }
-        const config = getConfig();
-        if (!config.watcherUrl) {
-            return reply.code(501).send({ error: 'Search not configured' });
-        }
+        const watcherUrl = getServiceUrl('watcher');
         // Return cached if fresh
         if (facetsCache &&
             Date.now() - facetsCache.fetchedAt < FACETS_CACHE_TTL_MS) {
@@ -189,7 +185,6 @@ export const searchRoutes = async (fastify) => {
         try {
             // Guard against cache stampede: reuse in-flight fetch
             if (!facetsFetchPromise) {
-                const watcherUrl = config.watcherUrl;
                 facetsFetchPromise = (async () => {
                     const watcherRes = await fetch(`${watcherUrl}/search/facets`, {
                         signal: AbortSignal.timeout(15000),

package/dist/src/routes/api/search.test.js

@@ -0,0 +1,28 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+vi.mock('@karmaniverous/jeeves', () => ({
+    getServiceUrl: vi.fn(),
+}));
+const { getServiceUrl } = await import('@karmaniverous/jeeves');
+const mockedGetServiceUrl = vi.mocked(getServiceUrl);
+describe('search watcher URL resolution', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('resolves watcher URL via core getServiceUrl', () => {
+        mockedGetServiceUrl.mockReturnValue('http://127.0.0.1:1936');
+        const url = getServiceUrl('watcher');
+        expect(url).toBe('http://127.0.0.1:1936');
+        expect(mockedGetServiceUrl).toHaveBeenCalledWith('watcher');
+    });
+    it('uses core-resolved URL, not a hardcoded default', () => {
+        mockedGetServiceUrl.mockReturnValue('http://10.0.0.5:8888');
+        const url = getServiceUrl('watcher');
+        expect(url).toBe('http://10.0.0.5:8888');
+    });
+    it('constructs search endpoint from resolved watcher URL', () => {
+        mockedGetServiceUrl.mockReturnValue('http://127.0.0.1:1936');
+        const watcherUrl = getServiceUrl('watcher');
+        expect(`${watcherUrl}/search`).toBe('http://127.0.0.1:1936/search');
+        expect(`${watcherUrl}/search/facets`).toBe('http://127.0.0.1:1936/search/facets');
+    });
+});

package/dist/src/routes/config.test.js

@@ -7,7 +7,6 @@ import { sanitizeConfig } from './config.js';
 function makeConfig(overrides = {}) {
     return {
         port: 1934,
-        host: '0.0.0.0',
         eventTimeoutMs: 30_000,
         eventLogPurgeMs: 604_800_000,
         maxZipSizeMb: 100,

package/dist/src/routes/event.js

@@ -1,7 +1,7 @@
 /**
  * Event Gateway webhook endpoint
  */
-import { JsonMap } from '@karmaniverous/jsonmap';
+import { JsonMap, } from '@karmaniverous/jsonmap';
 import Ajv from 'ajv';
 import * as _ from 'radash';
 import { verifyKey } from '../auth/keys.js';

package/dist/src/routes/status.js

@@ -4,7 +4,7 @@
  * Returns standard `{ name, version, uptime, status, health }` shape
  * with server-specific details nested under `health`.
  */
-import { createStatusHandler } from '@karmaniverous/jeeves';
+import { createStatusHandler, getServiceUrl } from '@karmaniverous/jeeves';
 import { getConfig } from '../config/index.js';
 import { packageVersion } from '../util/packageVersion.js';
 async function checkService(url) {
@@ -30,9 +30,9 @@ const handleStatus = createStatusHandler({
     getHealth: async () => {
         const config = getConfig();
         const [watcher, runner, meta] = await Promise.all([
-            config.watcherUrl ? checkService(config.watcherUrl) : null,
-            config.runnerUrl ? checkService(config.runnerUrl) : null,
-            config.metaUrl ? checkService(config.metaUrl) : null,
+            checkService(getServiceUrl('watcher')),
+            checkService(getServiceUrl('runner')),
+            checkService(getServiceUrl('meta')),
         ]);
         return {
             port: config.port,

package/dist/src/routes/status.test.js

@@ -1,8 +1,17 @@
 import { describe, expect, it, vi } from 'vitest';
+vi.mock('@karmaniverous/jeeves', async (importOriginal) => {
+    const mod = await importOriginal();
+    return {
+        ...mod,
+        getServiceUrl: (name) => `http://127.0.0.1:${name === 'watcher' ? '1936' : name === 'runner' ? '1937' : '1938'}`,
+    };
+});
+// Mock fetch so service health checks don't make real HTTP calls
+const mockFetch = vi.fn().mockRejectedValue(new Error('not reachable'));
+vi.stubGlobal('fetch', mockFetch);
 // Mock config
 const mockConfig = {
     port: 1934,
-    host: '0.0.0.0',
     chromePath: '/usr/bin/chromium',
     authModes: ['keys'],
     resolvedInsiders: [{ email: 'a@b.com' }, { email: 'c@d.com' }],
@@ -16,9 +25,6 @@ const mockConfig = {
         jarPath: '/tools/plantuml.jar',
         servers: ['https://plantuml.com/plantuml'],
     },
-    watcherUrl: null,
-    runnerUrl: null,
-    metaUrl: null,
     exportFormats: ['pdf', 'docx', 'zip'],
 };
 vi.mock('../config/index.js', () => ({

package/dist/src/server.js

@@ -7,6 +7,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import cookie from '@fastify/cookie';
 import fastifyStatic from '@fastify/static';
+import { getBindAddress } from '@karmaniverous/jeeves';
 import Fastify from 'fastify';
 import { getConfig, initConfig, isConfigInitialized } from './config/index.js';
 import { apiRoute } from './routes/api/index.js';
@@ -76,8 +77,9 @@ async function start() {
         initExportCache();
         // Start queue processor
         startQueueProcessor();
-        await fastify.listen({ port: config.port, host: config.host });
-        console.log(`Jeeves server listening on ${config.host}:${String(config.port)}`);
+        const bindAddress = getBindAddress('server');
+        await fastify.listen({ port: config.port, host: bindAddress });
+        console.log(`Jeeves server listening on ${bindAddress}:${String(config.port)}`);
         console.log(`Endpoints:`);
         console.log(`  GET  /browse/* - File browser SPA`);
         console.log(`  GET  /api/raw/*    - Raw file serving`);

package/dist/src/services/csv.js

@@ -0,0 +1,114 @@
+/**
+ * CSV to HTML table conversion.
+ *
+ * Parses RFC 4180 CSV and renders an HTML table with headers.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Parse a CSV string into rows of fields per RFC 4180.
+ *
+ * Handles: quoted fields with embedded commas/newlines,
+ * escaped quotes (""), empty fields, trailing newlines.
+ */
+export function parseCsvRows(csv) {
+    const rows = [];
+    let row = [];
+    let field = '';
+    let inQuotes = false;
+    let i = 0;
+    while (i < csv.length) {
+        const ch = csv[i];
+        if (inQuotes) {
+            if (ch === '"') {
+                // Peek next character
+                if (i + 1 < csv.length && csv[i + 1] === '"') {
+                    // Escaped quote
+                    field += '"';
+                    i += 2;
+                }
+                else {
+                    // End of quoted field
+                    inQuotes = false;
+                    i++;
+                }
+            }
+            else {
+                field += ch;
+                i++;
+            }
+        }
+        else {
+            if (ch === '"') {
+                inQuotes = true;
+                i++;
+            }
+            else if (ch === ',') {
+                row.push(field);
+                field = '';
+                i++;
+            }
+            else if (ch === '\r') {
+                // Handle \r\n or bare \r
+                row.push(field);
+                field = '';
+                rows.push(row);
+                row = [];
+                i++;
+                if (i < csv.length && csv[i] === '\n')
+                    i++;
+            }
+            else if (ch === '\n') {
+                row.push(field);
+                field = '';
+                rows.push(row);
+                row = [];
+                i++;
+            }
+            else {
+                field += ch;
+                i++;
+            }
+        }
+    }
+    // Push final field/row if there's content
+    if (field.length > 0 || row.length > 0) {
+        row.push(field);
+        rows.push(row);
+    }
+    // Remove trailing empty row (from trailing newline)
+    const lastRow = rows.length > 0 ? rows[rows.length - 1] : undefined;
+    if (lastRow && lastRow.length === 1 && lastRow[0] === '') {
+        rows.pop();
+    }
+    return rows;
+}
+/** Escape HTML special characters. */
+function escapeHtml(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+/**
+ * Convert a CSV string to an HTML table.
+ *
+ * First row is treated as column headers (thead).
+ * Returns empty paragraph for empty input.
+ */
+export function csvToHtmlTable(csv) {
+    const rows = parseCsvRows(csv);
+    if (rows.length === 0)
+        return '<p>Empty CSV</p>';
+    const [headers, ...data] = rows;
+    const colCount = headers.length;
+    const thead = `<thead><tr>${headers.map((h) => `<th>${escapeHtml(h)}</th>`).join('')}</tr></thead>`;
+    const tbody = `<tbody>${data
+        .map((row) => {
+        const cells = Array.from({ length: colCount }, (_, i) => row[i] ?? '');
+        return `<tr>${cells.map((cell) => `<td>${escapeHtml(cell)}</td>`).join('')}</tr>`;
+    })
+        .join('')}</tbody>`;
+    return `<table class="csv-table">${thead}${tbody}</table>`;
+}

package/dist/src/services/csv.test.js

@@ -0,0 +1,107 @@
+import { describe, expect, it } from 'vitest';
+import { csvToHtmlTable, parseCsvRows } from './csv.js';
+describe('parseCsvRows', () => {
+    it('parses simple CSV', () => {
+        const rows = parseCsvRows('a,b,c\n1,2,3\n');
+        expect(rows).toEqual([
+            ['a', 'b', 'c'],
+            ['1', '2', '3'],
+        ]);
+    });
+    it('handles quoted fields with embedded commas', () => {
+        const rows = parseCsvRows('name,desc\n"Smith, John","has, commas"\n');
+        expect(rows).toEqual([
+            ['name', 'desc'],
+            ['Smith, John', 'has, commas'],
+        ]);
+    });
+    it('handles escaped quotes ("")', () => {
+        const rows = parseCsvRows('a\n"he said ""hello"""\n');
+        expect(rows).toEqual([['a'], ['he said "hello"']]);
+    });
+    it('handles empty fields', () => {
+        const rows = parseCsvRows('a,,c\n,,\n');
+        expect(rows).toEqual([
+            ['a', '', 'c'],
+            ['', '', ''],
+        ]);
+    });
+    it('handles trailing newlines', () => {
+        const rows = parseCsvRows('a,b\n1,2\n\n');
+        expect(rows).toEqual([
+            ['a', 'b'],
+            ['1', '2'],
+        ]);
+    });
+    it('handles single row (headers only)', () => {
+        const rows = parseCsvRows('name,age,city\n');
+        expect(rows).toEqual([['name', 'age', 'city']]);
+    });
+    it('returns empty array for empty input', () => {
+        const rows = parseCsvRows('');
+        expect(rows).toEqual([]);
+    });
+    it('handles CRLF line endings', () => {
+        const rows = parseCsvRows('a,b\r\n1,2\r\n');
+        expect(rows).toEqual([
+            ['a', 'b'],
+            ['1', '2'],
+        ]);
+    });
+    it('handles quoted fields with embedded newlines', () => {
+        const rows = parseCsvRows('a,b\n"line1\nline2",val\n');
+        expect(rows).toEqual([
+            ['a', 'b'],
+            ['line1\nline2', 'val'],
+        ]);
+    });
+});
+describe('csvToHtmlTable', () => {
+    it('renders a table with headers and data', () => {
+        const html = csvToHtmlTable('Name,Age\nAlice,30\nBob,25\n');
+        expect(html).toContain('<thead>');
+        expect(html).toContain('<th>Name</th>');
+        expect(html).toContain('<th>Age</th>');
+        expect(html).toContain('<td>Alice</td>');
+        expect(html).toContain('<td>30</td>');
+        expect(html).toContain('<td>Bob</td>');
+    });
+    it('returns empty paragraph for empty input', () => {
+        const html = csvToHtmlTable('');
+        expect(html).toBe('<p>Empty CSV</p>');
+    });
+    it('escapes HTML in field values', () => {
+        const html = csvToHtmlTable('a\n<script>alert("xss")</script>\n');
+        expect(html).not.toContain('<script>');
+        expect(html).toContain('&lt;script&gt;');
+    });
+    it('produces a table with csv-table class for client styling', () => {
+        const html = csvToHtmlTable('Name,Age\nAlice,30\n');
+        expect(html).toMatch(/<table class="csv-table">/);
+    });
+    it('normalizes rows with fewer or more columns than header', () => {
+        // Row with fewer columns gets padded, row with more gets truncated
+        const csv = 'a,b,c\n1\n4,5,6,7\n';
+        const html = csvToHtmlTable(csv);
+        // First data row: 1 field → padded to 3 columns
+        expect(html).toContain('<tr><td>1</td><td></td><td></td></tr>');
+        // Second data row: 4 fields → truncated to 3 columns (no "7")
+        expect(html).toContain('<tr><td>4</td><td>5</td><td>6</td></tr>');
+        expect(html).not.toContain('<td>7</td>');
+    });
+    it('handles a large CSV (>100 rows) without issues', () => {
+        const header = 'id,name,value\n';
+        const rows = Array.from({ length: 150 }, (_, i) => `${String(i)},item${String(i)},${String(i * 10)}\n`).join('');
+        const csv = header + rows;
+        const html = csvToHtmlTable(csv);
+        expect(html).toContain('csv-table');
+        expect(html).toContain('<thead>');
+        // Verify first and last data rows are present
+        expect(html).toContain('<td>0</td>');
+        expect(html).toContain('<td>149</td>');
+        // Count tbody rows
+        const trMatches = html.match(/<tr>/g);
+        // 1 header row + 150 data rows = 151
+        expect(trMatches).toHaveLength(151);
+    });
+});

package/dist/src/services/markdown.js

@@ -146,11 +146,31 @@ export function parseMarkdown(markdown, options = {}) {
     let html = marked(processedMarkdown);
     // Prepend frontmatter as a rendered YAML code block
     if (frontmatter) {
+        const FRONTMATTER_COLLAPSE_THRESHOLD = 10;
         const escaped = frontmatter
             .replace(/&/g, '&')
             .replace(/</g, '&lt;')
             .replace(/>/g, '&gt;');
-        html = `<div class="frontmatter-block"><pre><code class="language-yaml">${escaped}</code></pre></div>\n${html}`;
+        const lines = frontmatter.split('\n');
+        if (lines.length > FRONTMATTER_COLLAPSE_THRESHOLD) {
+            const previewEscaped = lines
+                .slice(0, FRONTMATTER_COLLAPSE_THRESHOLD)
+                .join('\n')
+                .replace(/&/g, '&amp;')
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;');
+            html =
+                `<div class="frontmatter-block frontmatter-collapsible">` +
+                    `<div class="frontmatter-preview"><pre><code class="language-yaml">${previewEscaped}</code></pre></div>` +
+                    `<div class="frontmatter-full"><pre><code class="language-yaml">${escaped}</code></pre></div>` +
+                    `<button class="frontmatter-toggle" onclick="this.parentElement.classList.toggle('frontmatter-expanded'); ` +
+                    `this.textContent = this.parentElement.classList.contains('frontmatter-expanded') ` +
+                    `? 'Show less' : 'Show all (${String(lines.length)} lines)'">Show all (${String(lines.length)} lines)</button>` +
+                    `</div>\n${html}`;
+        }
+        else {
+            html = `<div class="frontmatter-block"><pre><code class="language-yaml">${escaped}</code></pre></div>\n${html}`;
+        }
     }
     return { html, headings };
 }

package/dist/src/services/markdown.test.js

@@ -20,3 +20,46 @@ describe('parseMarkdown', () => {
         expect(headings[0].text).toBe('It\'s a "test"');
     });
 });
+describe('collapsible frontmatter', () => {
+    function makeFrontmatter(lineCount) {
+        const lines = Array.from({ length: lineCount }, (_, i) => `key${String(i)}: value${String(i)}`);
+        return `---\n${lines.join('\n')}\n---\n# Body`;
+    }
+    it('collapses frontmatter with >10 lines', () => {
+        const md = makeFrontmatter(15);
+        const { html } = parseMarkdown(md);
+        expect(html).toContain('frontmatter-collapsible');
+        expect(html).toContain('frontmatter-toggle');
+        expect(html).toContain('Show all (15 lines)');
+    });
+    it('does not collapse frontmatter with ≤10 lines', () => {
+        const md = makeFrontmatter(8);
+        const { html } = parseMarkdown(md);
+        expect(html).toContain('frontmatter-block');
+        expect(html).not.toContain('frontmatter-collapsible');
+        expect(html).not.toContain('frontmatter-toggle');
+    });
+    it('preview section contains only the first 10 lines', () => {
+        const md = makeFrontmatter(20);
+        const { html } = parseMarkdown(md);
+        const previewMatch = html.match(/frontmatter-preview.*?<code[^>]*>([\s\S]*?)<\/code>/);
+        expect(previewMatch).not.toBeNull();
+        const previewContent = previewMatch[1];
+        const previewLines = previewContent.split('\n');
+        expect(previewLines).toHaveLength(10);
+        expect(previewLines[0]).toContain('key0');
+        expect(previewLines[9]).toContain('key9');
+    });
+    it('does NOT collapse frontmatter with exactly 10 lines', () => {
+        const md = makeFrontmatter(10);
+        const { html } = parseMarkdown(md);
+        expect(html).toContain('frontmatter-block');
+        expect(html).not.toContain('frontmatter-collapsible');
+    });
+    it('collapses frontmatter with exactly 11 lines', () => {
+        const md = makeFrontmatter(11);
+        const { html } = parseMarkdown(md);
+        expect(html).toContain('frontmatter-collapsible');
+        expect(html).toContain('Show all (11 lines)');
+    });
+});

package/dist/src/util/packageVersion.js

@@ -1,16 +1,6 @@
 /**
- * Resolve the service package version using package-directory.
+ * Resolve the service package version using core's getPackageVersion().
  */
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { packageDirectorySync } from 'package-directory';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const pkgDir = packageDirectorySync({ cwd: __dirname });
-if (!pkgDir) {
-    throw new Error('Could not find package directory for jeeves-server');
-}
-const pkgPath = path.join(pkgDir, 'package.json');
-const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+import { getPackageVersion } from '@karmaniverous/jeeves';
 /** The package version of the jeeves-server service package. */
-export const packageVersion = pkg.version;
+export const packageVersion = getPackageVersion(import.meta.url);

package/guides/deployment.md

@@ -8,7 +8,7 @@ How to run Jeeves Server in production.
 
 ## Prerequisites
 
-- **Node.js** ≥ 20
+- **Node.js** ≥ 22
 - **Chrome or Chromium** — for PDF/DOCX export via Puppeteer
 - **A domain** with HTTPS — required for Google OAuth and secure sharing
 - **A reverse proxy** — Caddy, nginx, or similar (recommended)