@karmaniverous/jeeves-server 3.5.2 → 3.6.0

package/src/routes/api/export.ts

@@ -10,6 +10,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
+import { getBindAddress } from '@karmaniverous/jeeves';
 import archiver from 'archiver';
 import type { FastifyPluginAsync } from 'fastify';
 
@@ -102,7 +103,10 @@ export const exportRoutes: FastifyPluginAsync = async (fastify) => {
           .code(500)
           .send({ error: 'Export unavailable — no internal key configured' });
 
-      const exportUrl = `http://127.0.0.1:${String(port)}/browse/${reqPath}?key=${exportKey}&render_diagrams=1&plain_code=1`;
+      const bindAddr = getBindAddress('server');
+      // Use loopback if bound to all interfaces (0.0.0.0 is not a valid request target)
+      const renderHost = bindAddr === '0.0.0.0' ? '127.0.0.1' : bindAddr;
+      const exportUrl = `http://${renderHost}:${String(port)}/browse/${reqPath}?key=${exportKey}&render_diagrams=1&plain_code=1`;
       const fileName = path.basename(resolved);
       const baseName = fileName.replace(/\.md$/i, '');
 

package/src/routes/api/fileContent.ts

@@ -7,9 +7,11 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
+import { getServiceUrl } from '@karmaniverous/jeeves';
 import type { FastifyPluginAsync, FastifyReply, FastifyRequest } from 'fastify';
 
 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 {
@@ -142,6 +144,29 @@ export const fileContentRoutes: FastifyPluginAsync = async (fastify) => {
         });
       }
 
+      // 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)) {
@@ -259,11 +284,10 @@ interface WatcherRenderResponse {
 async function tryWatcherRender(
   fsPath: string,
 ): Promise<WatcherRenderResponse | null> {
-  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/src/routes/api/runner.test.ts

@@ -0,0 +1,39 @@
+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/src/routes/api/runner.ts

@@ -5,14 +5,11 @@
  * so jeeves-server acts as an authenticated gateway.
  */
 
+import { getServiceUrl } from '@karmaniverous/jeeves';
 import type { FastifyPluginAsync, FastifyReply } from 'fastify';
 
-import { getConfig } from '../../config/index.js';
-
-const DEFAULT_RUNNER_URL = 'http://127.0.0.1:3100';
-
 function getRunnerUrl(): string {
-  return getConfig().runnerUrl ?? DEFAULT_RUNNER_URL;
+  return getServiceUrl('runner');
 }
 
 /** Proxy a request to the runner and send the response via reply. */

package/src/routes/api/search.test.ts

@@ -0,0 +1,36 @@
+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/src/routes/api/search.ts

@@ -9,6 +9,7 @@
 
 import { stat } from 'node:fs/promises';
 
+import { getServiceUrl } from '@karmaniverous/jeeves';
 import type { FastifyPluginAsync } from 'fastify';
 import picomatch from 'picomatch';
 
@@ -86,9 +87,7 @@ export const searchRoutes: FastifyPluginAsync = async (fastify) => {
     }
 
     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') {
@@ -102,7 +101,7 @@ export const searchRoutes: FastifyPluginAsync = async (fastify) => {
     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 }),
@@ -244,10 +243,7 @@ export const searchRoutes: FastifyPluginAsync = 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');
 
     // Return cached if fresh
     if (
@@ -260,7 +256,6 @@ export const searchRoutes: FastifyPluginAsync = 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/src/routes/config.test.ts

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

package/src/routes/status.test.ts

@@ -1,9 +1,21 @@
 import { describe, expect, it, vi } from 'vitest';
 
+vi.mock('@karmaniverous/jeeves', async (importOriginal) => {
+  const mod = await importOriginal<Record<string, unknown>>();
+  return {
+    ...mod,
+    getServiceUrl: (name: string) =>
+      `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' }],
@@ -17,9 +29,6 @@ const mockConfig = {
     jarPath: '/tools/plantuml.jar',
     servers: ['https://plantuml.com/plantuml'],
   },
-  watcherUrl: null,
-  runnerUrl: null,
-  metaUrl: null,
   exportFormats: ['pdf', 'docx', 'zip'],
 };
 

package/src/routes/status.ts

@@ -5,7 +5,7 @@
  * with server-specific details nested under `health`.
  */
 
-import { createStatusHandler } from '@karmaniverous/jeeves';
+import { createStatusHandler, getServiceUrl } from '@karmaniverous/jeeves';
 import type { FastifyPluginAsync } from 'fastify';
 
 import { getConfig } from '../config/index.js';
@@ -41,9 +41,9 @@ const handleStatus = createStatusHandler({
     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 {

package/src/server.ts

@@ -9,6 +9,7 @@ import { fileURLToPath } from 'node:url';
 
 import cookie from '@fastify/cookie';
 import fastifyStatic from '@fastify/static';
+import { getBindAddress } from '@karmaniverous/jeeves';
 import Fastify, { type FastifyReply, type FastifyRequest } from 'fastify';
 
 import { getConfig, initConfig, isConfigInitialized } from './config/index.js';
@@ -97,9 +98,10 @@ async function start() {
     // Start queue processor
     startQueueProcessor();
 
-    await fastify.listen({ port: config.port, host: config.host });
+    const bindAddress = getBindAddress('server');
+    await fastify.listen({ port: config.port, host: bindAddress });
     console.log(
-      `Jeeves server listening on ${config.host}:${String(config.port)}`,
+      `Jeeves server listening on ${bindAddress}:${String(config.port)}`,
     );
     console.log(`Endpoints:`);
     console.log(`  GET  /browse/* - File browser SPA`);

package/src/services/csv.test.ts

@@ -0,0 +1,127 @@
+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/src/services/csv.ts

@@ -0,0 +1,115 @@
+/**
+ * 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: string): string[][] {
+  const rows: string[][] = [];
+  let row: string[] = [];
+  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: string): string {
+  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: string): string {
+  const rows = parseCsvRows(csv);
+  if (rows.length === 0) return '<p>Empty CSV</p>';
+
+  const [headers, ...data] = rows as [string[], ...string[][]];
+  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/src/services/markdown.test.ts

@@ -24,3 +24,57 @@ describe('parseMarkdown', () => {
     expect(headings[0].text).toBe('It\'s a "test"');
   });
 });
+
+describe('collapsible frontmatter', () => {
+  function makeFrontmatter(lineCount: number): string {
+    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/src/services/markdown.ts

@@ -197,11 +197,31 @@ export function parseMarkdown(
 
   // 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/src/util/packageVersion.ts

@@ -1,23 +1,8 @@
 /**
- * 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')) as {
-  version: string;
-};
+import { getPackageVersion } from '@karmaniverous/jeeves';
 
 /** The package version of the jeeves-server service package. */
-export const packageVersion: string = pkg.version;
+export const packageVersion: string = getPackageVersion(import.meta.url);