@jenga-ai/agent 3.1.1 → 3.4.0

package/project/app/api/response.js

@@ -0,0 +1,47 @@
+/**
+ * @file api/response.js
+ * Helper functions for building consistent API response envelopes.
+ */
+
+const API_VERSION = '1.0.0';
+
+/**
+ * Build a success envelope.
+ * @template T
+ * @param {T} data
+ * @param {Object} [extraMeta] - Additional meta fields to merge
+ * @returns {import('./types').ApiEnvelope<T>}
+ */
+function successResponse(data, extraMeta = {}) {
+  return {
+    data,
+    meta: {
+      timestamp: new Date().toISOString(),
+      version: API_VERSION,
+      ...extraMeta,
+    },
+    error: null,
+  };
+}
+
+/**
+ * Build an error envelope.
+ * @param {string} code    - Error code from ERROR_CODES
+ * @param {string} message - Human-readable message
+ * @param {Object} [details]
+ * @returns {import('./types').ApiEnvelope<null>}
+ */
+function errorResponse(code, message, details) {
+  const err = { code, message };
+  if (details !== undefined) err.details = details;
+  return {
+    data: null,
+    meta: {
+      timestamp: new Date().toISOString(),
+      version: API_VERSION,
+    },
+    error: err,
+  };
+}
+
+module.exports = { successResponse, errorResponse, API_VERSION };

package/project/app/api/routes/architecture.js

@@ -0,0 +1,23 @@
+/**
+ * @file project/app/api/routes/architecture.js
+ * GET /architecture — tech stack and dependency metadata
+ */
+
+const { Router } = require('express');
+const { parseArchitecture } = require('../parsers/architecture');
+const { successResponse, errorResponse } = require('../response');
+const { ERROR_CODES } = require('../types');
+
+const router = Router();
+
+router.get('/', async (req, res) => {
+  try {
+    const arch = await parseArchitecture();
+    res.json(successResponse(arch));
+  } catch (err) {
+    console.error('[architecture] error:', err.message);
+    res.status(500).json(errorResponse(ERROR_CODES.INTERNAL_ERROR, err.message));
+  }
+});
+
+module.exports = router;

package/project/app/api/routes/board.js

@@ -0,0 +1,46 @@
+/**
+ * @file project/app/api/routes/board.js
+ * GET /board          — full nested board
+ * GET /board/:epicId  — single epic (case-insensitive)
+ */
+
+const { Router } = require('express');
+const { parseBoard } = require('../parsers/board');
+const { successResponse, errorResponse } = require('../response');
+const { ERROR_CODES } = require('../types');
+
+const router = Router();
+
+router.get('/', async (req, res) => {
+  try {
+    const board = await parseBoard();
+    res.json(successResponse(board));
+  } catch (err) {
+    console.error('[board] parse error:', err.message);
+    res.status(500).json(errorResponse(ERROR_CODES.PARSE_ERROR, err.message));
+  }
+});
+
+router.get('/:epicId', async (req, res) => {
+  try {
+    const board = await parseBoard();
+    const id = req.params.epicId.toLowerCase();
+    const epic = board.find((e) => e.id && e.id.toLowerCase() === id);
+    if (!epic) {
+      return res
+        .status(404)
+        .json(
+          errorResponse(
+            ERROR_CODES.EPIC_NOT_FOUND,
+            `Epic '${req.params.epicId}' not found`
+          )
+        );
+    }
+    res.json(successResponse(epic));
+  } catch (err) {
+    console.error('[board/:epicId] parse error:', err.message);
+    res.status(500).json(errorResponse(ERROR_CODES.PARSE_ERROR, err.message));
+  }
+});
+
+module.exports = router;

package/project/app/api/routes/documentation.js

@@ -0,0 +1,24 @@
+/**
+ * @file project/app/api/routes/documentation.js
+ * GET / — full documentation aggregate (summary/readme/strategy/example), untruncated, no query
+ * params or pagination — matches GET /v1/board's bulk-fetch precedent.
+ */
+
+const { Router } = require('express');
+const { readDocumentation } = require('../parsers/documentation');
+const { successResponse, errorResponse } = require('../response');
+const { ERROR_CODES } = require('../types');
+
+const router = Router();
+
+router.get('/', async (req, res) => {
+  try {
+    const documentation = await readDocumentation();
+    res.json(successResponse(documentation));
+  } catch (err) {
+    console.error('[documentation] parse error:', err.message);
+    res.status(500).json(errorResponse(ERROR_CODES.PARSE_ERROR, err.message));
+  }
+});
+
+module.exports = router;

package/project/app/api/routes/health.js

@@ -0,0 +1,25 @@
+/**
+ * @file project/app/api/routes/health.js
+ * GET /health — server liveness check
+ */
+
+const { Router } = require('express');
+const { successResponse } = require('../response');
+const { API_VERSION } = require('../response');
+
+const router = Router();
+
+const startTime = Date.now();
+
+router.get('/', (req, res) => {
+  const uptime = (Date.now() - startTime) / 1000;
+  res.json(
+    successResponse({
+      status: 'ok',
+      version: API_VERSION,
+      uptime,
+    })
+  );
+});
+
+module.exports = router;

package/project/app/api/routes/history.js

@@ -0,0 +1,55 @@
+/**
+ * @file project/app/api/routes/history.js
+ * GET /history — merged git commits + rapport files, sorted by date desc
+ * Query params:
+ *   ?limit=N          — return first N items
+ *   ?type=git_commit|rapport — filter by type
+ */
+
+const { Router } = require('express');
+const { readGitLog } = require('../parsers/git-log');
+const { readRapports } = require('../parsers/rapports');
+const { successResponse, errorResponse } = require('../response');
+const { ERROR_CODES } = require('../types');
+
+const router = Router();
+
+router.get('/', async (req, res) => {
+  const { limit, type } = req.query;
+
+  if (limit !== undefined && (isNaN(Number(limit)) || Number(limit) < 1)) {
+    return res
+      .status(400)
+      .json(
+        errorResponse(ERROR_CODES.INVALID_QUERY_PARAM, '`limit` must be a positive integer')
+      );
+  }
+  if (type !== undefined && !['git_commit', 'rapport'].includes(type)) {
+    return res
+      .status(400)
+      .json(
+        errorResponse(ERROR_CODES.INVALID_QUERY_PARAM, '`type` must be git_commit or rapport')
+      );
+  }
+
+  try {
+    const [commits, rapports] = await Promise.all([readGitLog(), readRapports()]);
+    let items = [...commits, ...rapports];
+
+    items.sort((a, b) => {
+      const da = new Date(a.date || 0).getTime();
+      const db = new Date(b.date || 0).getTime();
+      return db - da;
+    });
+
+    if (type) items = items.filter((i) => i.type === type);
+    if (limit) items = items.slice(0, Number(limit));
+
+    res.json(successResponse(items));
+  } catch (err) {
+    console.error('[history] error:', err.message);
+    res.status(500).json(errorResponse(ERROR_CODES.INTERNAL_ERROR, err.message));
+  }
+});
+
+module.exports = router;

package/project/app/api/routes/rapports.js

@@ -0,0 +1,24 @@
+/**
+ * @file project/app/api/routes/rapports.js
+ * GET / — full rapports aggregate (analysis/problems/tests/summaries/plans/idea), untruncated,
+ * no query params or pagination — matches GET /v1/board's bulk-fetch precedent.
+ */
+
+const { Router } = require('express');
+const { readRapportsFull } = require('../parsers/rapports');
+const { successResponse, errorResponse } = require('../response');
+const { ERROR_CODES } = require('../types');
+
+const router = Router();
+
+router.get('/', async (req, res) => {
+  try {
+    const rapports = await readRapportsFull();
+    res.json(successResponse(rapports));
+  } catch (err) {
+    console.error('[rapports] parse error:', err.message);
+    res.status(500).json(errorResponse(ERROR_CODES.PARSE_ERROR, err.message));
+  }
+});
+
+module.exports = router;

package/project/app/api/scripts/capture-snapshot.js

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+/**
+ * @file project/app/api/scripts/capture-snapshot.js
+ *
+ * E47_S04_T02 — capture step for `j.dashboard --snapshot`.
+ *
+ * Calls the dashboard API's `/v1/board`, `/v1/history`, and `/v1/architecture` routes exactly once
+ * each and writes their combined JSON to a single artifact, consumable by the bundling/inlining
+ * step in `E47_S04_T03` (not yet implemented — this script's job ends at "artifact written to
+ * disk").
+ *
+ * ── Why an ad-hoc, in-process server instead of hitting an already-running one ──────────────────
+ * This script always spins up its own short-lived, ephemeral (`--port 0` by default) server
+ * instance bound to an explicitly resolved project root, rather than assuming or reaching for some
+ * already-running dashboard server. An already-running server on a well-known port (e.g. 3001)
+ * could be serving an entirely different project root's data — reusing it would silently defeat
+ * the "capture the *invoking* project's data, not this repo's" requirement this task exists to
+ * satisfy. A freshly spawned, request-scoped instance removes that ambiguity entirely: whatever
+ * root this script resolves is unambiguously the root the three routes below will answer for.
+ *
+ * ── Reuses E47_S02's generalized data-source resolution — does not re-derive it ─────────────────
+ * `../lib/resolve-project-root.js`'s `resolveProjectRoot()` (added by E47_S02_T01, wired into
+ * `../server.js` and every parser by E47_S02_T02) is the sole path-resolution mechanism used here:
+ *   - `--project-root <path>`, if given, is set as the `JENGA_PROJECT_ROOT` env var *before*
+ *     calling `resolveProjectRoot()` — i.e. it drives E47_S02's own primary override mechanism
+ *     (the same one `server.js`'s own doc comment names as the future `jenga dashboard start` CLI's
+ *     intended integration path), rather than inventing a second override convention.
+ *   - If `--project-root` is not given, `resolveProjectRoot({ cwd: process.cwd() })` is called with
+ *     no override — exactly mirroring `server.js`'s own no-override behavior (walk up from cwd
+ *     looking for a `project/board` marker, fail loudly if none is found within the bound).
+ *   - Either way, the *resolved* (realpath'd) value is then re-pinned onto `JENGA_PROJECT_ROOT`
+ *     before `../server` is required, so `server.js`'s own load-time check
+ *     (`if (!process.env.JENGA_PROJECT_ROOT) { ... }`) short-circuits and never re-derives
+ *     resolution — every parser downstream agrees with exactly what this script already validated.
+ * If `resolveProjectRoot()` ever throws (e.g. no `project/board` marker found, or an explicit
+ * `--project-root` that doesn't exist), this script fails loudly with that same descriptive error
+ * and never starts a server or writes a partial artifact.
+ *
+ * ── Output artifact shape (the hand-off contract for E47_S04_T03) ────────────────────────────────
+ * A single UTF-8 JSON file:
+ * {
+ *   "schema_version": 1,
+ *   "captured_at": "<ISO 8601 UTC timestamp>",
+ *   "project_root": "<absolute, realpath'd project root this snapshot was captured against>",
+ *   "routes": {
+ *     "board":        <full API envelope from GET /v1/board,        i.e. { data, meta, error }>,
+ *     "history":       <full API envelope from GET /v1/history,      i.e. { data, meta, error }>,
+ *     "architecture":  <full API envelope from GET /v1/architecture, i.e. { data, meta, error }>
+ *   }
+ * }
+ * Each `routes.<name>` value is the *full* envelope exactly as the route returned it (see
+ * `../response.js`'s `successResponse`/`errorResponse` shape) — deliberately not unwrapped to a
+ * bare `.data` — so `E47_S04_T03`'s bundler can decide for itself how to feed this into the UI's
+ * existing `client.js` request contract (which itself expects `{ data, meta, error }` and throws on
+ * a truthy `error`) without this task guessing that choice on its behalf. Since capture already
+ * hard-fails on any route error (see below), `error` will always be `null` in a written artifact —
+ * it is kept in the shape anyway so the two representations (a live API response vs. a captured
+ * one) stay structurally identical.
+ *
+ * ── Failure behavior ──────────────────────────────────────────────────────────────────────────
+ * Any of the following is treated as a hard failure: the ad-hoc server fails to start, a route
+ * request errors at the network level, a route responds with a non-2xx status, a route responds
+ * with non-JSON, or a route's own JSON envelope carries a truthy `error` field. In every case: the
+ * ad-hoc server is closed, a specific, actionable message is printed to stderr (naming the route
+ * and the failure reason), the process exits non-zero, and **no artifact is written** — never a
+ * partial or silently-empty snapshot.
+ *
+ * ── Node compatibility ────────────────────────────────────────────────────────────────────────
+ * Uses the built-in `http` module rather than global `fetch`, to stay compatible with the root
+ * `package.json`'s declared `engines.node: >=14.13.1` floor (global `fetch` only became available
+ * unflagged in Node 18).
+ *
+ * Usage:
+ *   node capture-snapshot.js [--project-root <path>] [--out <path>] [--port <n>]
+ *
+ *   --project-root <path>  Explicit project root override (see above). Default: resolve by
+ *                          walking up from the current working directory.
+ *   --out <path>           Where to write the combined snapshot JSON. Default:
+ *                          "./dashboard-snapshot-data.json" (relative to cwd). Final on-disk
+ *                          location for a real `--snapshot` run is E47_S04_T03's call, not this
+ *                          script's — it only writes wherever `--out` points.
+ *   --port <n>             Port for the ad-hoc capture server. Default: 0 (OS-assigned ephemeral
+ *                          port) — deliberately not the dashboard's usual default port, so this
+ *                          never collides with (or is confused for) a real already-running server.
+ */
+
+'use strict';
+
+const path = require('path');
+const http = require('http');
+const fs = require('fs');
+
+const ROUTES = ['/v1/board', '/v1/history', '/v1/architecture'];
+const ROUTE_KEYS = {
+  '/v1/board': 'board',
+  '/v1/history': 'history',
+  '/v1/architecture': 'architecture',
+};
+
+function printUsage() {
+  console.log(`Usage: capture-snapshot.js [--project-root <path>] [--out <path>] [--port <n>]
+
+  --project-root <path>  Explicit project root override, passed through to E47_S02's
+                          resolveProjectRoot() as the JENGA_PROJECT_ROOT override (the same
+                          mechanism server.js itself honors). Defaults to walking up from the
+                          current working directory looking for a project/board marker.
+  --out <path>            Where to write the combined snapshot JSON.
+                          Default: ./dashboard-snapshot-data.json (relative to cwd).
+  --port <n>              Port for the ad-hoc capture server instance. Default: 0
+                          (OS-assigned ephemeral port).
+`);
+}
+
+function die(message) {
+  console.error(`Error: capture-snapshot: ${message}`);
+  process.exit(1);
+}
+
+function parseArgs(argv) {
+  const args = { projectRoot: null, out: null, port: 0 };
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    switch (token) {
+      case '--project-root':
+        args.projectRoot = argv[++i];
+        if (!args.projectRoot) die('--project-root requires a value');
+        break;
+      case '--out':
+        args.out = argv[++i];
+        if (!args.out) die('--out requires a value');
+        break;
+      case '--port': {
+        const raw = argv[++i];
+        const parsed = parseInt(raw, 10);
+        if (raw === undefined || isNaN(parsed) || parsed < 0 || parsed > 65535) {
+          die(`--port must be a valid port number (0-65535), got: ${raw}`);
+        }
+        args.port = parsed;
+        break;
+      }
+      case '-h':
+      case '--help':
+        printUsage();
+        process.exit(0);
+        break;
+      default:
+        printUsage();
+        die(`unknown argument: ${token}`);
+    }
+  }
+  return args;
+}
+
+/**
+ * Issue a single GET request to the ad-hoc capture server and parse its JSON envelope. Rejects
+ * (rather than resolving with a partial/error payload) on any network error, non-2xx status,
+ * non-JSON body, or a truthy `error` field in the parsed envelope — the caller treats a rejection
+ * as a hard capture failure.
+ */
+function fetchJson(port, routePath) {
+  return new Promise((resolve, reject) => {
+    const req = http.get(
+      { host: '127.0.0.1', port, path: routePath, timeout: 15000 },
+      (res) => {
+        let body = '';
+        res.setEncoding('utf8');
+        res.on('data', (chunk) => {
+          body += chunk;
+        });
+        res.on('end', () => {
+          let parsed;
+          try {
+            parsed = JSON.parse(body);
+          } catch (err) {
+            reject(
+              new Error(
+                `${routePath} returned a non-JSON response (status ${res.statusCode}): ${err.message}`
+              )
+            );
+            return;
+          }
+          if (res.statusCode < 200 || res.statusCode >= 300 || (parsed && parsed.error)) {
+            const reason =
+              parsed && parsed.error
+                ? `${parsed.error.code}: ${parsed.error.message}`
+                : `HTTP ${res.statusCode}`;
+            reject(new Error(`${routePath} returned an error response — ${reason}`));
+            return;
+          }
+          resolve(parsed);
+        });
+      }
+    );
+    req.on('timeout', () => {
+      req.destroy(new Error(`${routePath} timed out after 15s — is the capture server reachable?`));
+    });
+    req.on('error', (err) => {
+      reject(new Error(`${routePath} request failed: ${err.message} — is the capture server reachable?`));
+    });
+  });
+}
+
+function startServer(app, port) {
+  return new Promise((resolve, reject) => {
+    const server = app.listen(port, '127.0.0.1');
+    server.once('listening', () => resolve(server));
+    server.once('error', (err) => {
+      reject(new Error(`could not start the ad-hoc capture server on port ${port}: ${err.message}`));
+    });
+  });
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  // eslint-disable-next-line global-require
+  const { resolveProjectRoot } = require('../lib/resolve-project-root');
+
+  if (args.projectRoot) {
+    // Drive E47_S02's own primary override mechanism rather than inventing a second one.
+    process.env.JENGA_PROJECT_ROOT = args.projectRoot;
+  }
+
+  let resolvedRoot;
+  try {
+    resolvedRoot = resolveProjectRoot();
+  } catch (err) {
+    die(err.message);
+    return; // unreachable — die() exits — but keeps linters happy about resolvedRoot's usage below
+  }
+
+  // Re-pin the *resolved* (realpath'd) value so server.js's own load-time resolution becomes a
+  // no-op and every downstream parser agrees with what was just validated here.
+  process.env.JENGA_PROJECT_ROOT = resolvedRoot;
+
+  const outPath = path.resolve(args.out || 'dashboard-snapshot-data.json');
+
+  let app;
+  try {
+    // eslint-disable-next-line global-require
+    ({ app } = require('../server'));
+  } catch (err) {
+    die(`failed to load the dashboard API server: ${err.message}`);
+    return;
+  }
+
+  let server;
+  try {
+    server = await startServer(app, args.port);
+  } catch (err) {
+    die(err.message);
+    return;
+  }
+
+  const boundPort = server.address().port;
+
+  const routeResults = {};
+  try {
+    for (const routePath of ROUTES) {
+      // Sequential, not parallel: on the first failure we stop immediately with a clear,
+      // single-cause error rather than a pile of concurrent rejections to untangle.
+      // eslint-disable-next-line no-await-in-loop
+      routeResults[ROUTE_KEYS[routePath]] = await fetchJson(boundPort, routePath);
+    }
+  } catch (err) {
+    server.close();
+    die(`snapshot capture failed — ${err.message}. No artifact was written.`);
+    return;
+  }
+
+  server.close();
+
+  const snapshot = {
+    schema_version: 1,
+    captured_at: new Date().toISOString(),
+    project_root: resolvedRoot,
+    routes: routeResults,
+  };
+
+  try {
+    fs.writeFileSync(outPath, `${JSON.stringify(snapshot, null, 2)}\n`);
+  } catch (err) {
+    die(`failed to write snapshot artifact to ${outPath}: ${err.message}`);
+    return;
+  }
+
+  console.log(`Snapshot captured: ${outPath}`);
+  console.log(`  project_root: ${resolvedRoot}`);
+  console.log(`  routes: ${Object.keys(routeResults).join(', ')}`);
+}
+
+main().catch((err) => {
+  die(err && err.stack ? err.stack : String(err));
+});

package/project/app/api/server.js

@@ -0,0 +1,112 @@
+/**
+ * @file project/app/api/server.js
+ * Jenga AI API server entry point.
+ *
+ * Usage:
+ *   node project/app/api/server.js
+ *   JENGA_API_PORT=4000 node project/app/api/server.js
+ */
+
+'use strict';
+
+const { resolveProjectRoot } = require('./lib/resolve-project-root');
+
+// Pin the resolved project root as an explicit override *before* any router/parser module loads —
+// each parser (board.js, git-log.js, rapports.js, architecture.js, knowledge-graph.js) computes its
+// own root via resolveProjectRoot() at its own module-load time, so this must run first.
+//
+// Deliberately calls resolveProjectRoot() rather than setting a raw `process.cwd()` literal: the
+// real launch paths in this repo (root `npm run dashboard:start`/`api:start`, both of which use
+// `--prefix project/app`) run with `cwd` set to `project/app` by npm, not the repo root — and
+// `project/app` itself has no `project/board` two levels below it (`project/board` is a *sibling*
+// of `project/app`). A raw `cwd` override would incorrectly `throw` in that case. Calling
+// resolveProjectRoot() here performs the same override-else-walk-up resolution the module already
+// does (walk-up from `cwd` correctly finds `project/board` above `project/app`), then pins that
+// *resolved* value into the env var — every parser's own subsequent call becomes a cheap env-var
+// read instead of repeating the walk, and every parser is guaranteed to agree on the same root even
+// if `process.cwd()` changes later in this process's lifetime. If a caller already set an override
+// (e.g. a future `jenga dashboard start` CLI subcommand that knows the user's true invocation
+// directory more reliably than this process's own `cwd`), this is a no-op — resolveProjectRoot()
+// already treats an explicit override as authoritative over any walk-up.
+if (!process.env.JENGA_PROJECT_ROOT) {
+  process.env.JENGA_PROJECT_ROOT = resolveProjectRoot();
+}
+
+const express = require('express');
+const cors    = require('cors');
+
+const healthRouter        = require('./routes/health');
+const boardRouter         = require('./routes/board');
+const historyRouter       = require('./routes/history');
+const architectureRouter  = require('./routes/architecture');
+const rapportsRouter      = require('./routes/rapports');
+const documentationRouter = require('./routes/documentation');
+
+const { API_VERSION } = require('./response');
+
+const PORT = parseInt(process.env.JENGA_API_PORT || '3001', 10);
+
+const app = express();
+
+// ── Middleware ─────────────────────────────────────────────────────────────────
+app.use(cors());
+app.use(express.json());
+
+// ── Routes ─────────────────────────────────────────────────────────────────────
+app.use('/v1/health',        healthRouter);
+app.use('/v1/board',         boardRouter);
+app.use('/v1/history',       historyRouter);
+app.use('/v1/architecture',  architectureRouter);
+app.use('/v1/rapports',      rapportsRouter);
+app.use('/v1/documentation', documentationRouter);
+
+// ── Fallback routes ────────────────────────────────────────────────────────────
+// Registered on demand (not at require-time) so callers that mount additional
+// routes on `app` after requiring this module — e.g. dashboard-start.cjs
+// serving the built UI — can do so before the catch-all 404 swallows them.
+const { errorResponse } = require('./response');
+const { ERROR_CODES }   = require('./types');
+
+function attachFallbackRoutes(targetApp, { rootRedirect = true } = {}) {
+  if (rootRedirect) {
+    targetApp.get('/', (req, res) => res.redirect('/v1/health'));
+  }
+
+  targetApp.use((req, res) => {
+    res.status(404).json(errorResponse(ERROR_CODES.NOT_FOUND, `Route '${req.path}' not found`));
+  });
+}
+
+// ── Start ──────────────────────────────────────────────────────────────────────
+let server;
+
+if (require.main === module) {
+  attachFallbackRoutes(app);
+  server = app.listen(PORT, () => {
+    console.log(`[jenga-api] v${API_VERSION} listening on port ${PORT}`);
+  });
+  registerShutdownHandlers(server);
+}
+
+// ── Graceful Shutdown ──────────────────────────────────────────────────────────
+function registerShutdownHandlers(srv) {
+  const FORCE_EXIT_MS = 5000;
+
+  function shutdown(signal) {
+    console.log(`[jenga-api] Received ${signal} — shutting down gracefully…`);
+    srv.close(() => {
+      console.log('[jenga-api] All connections closed. Exiting cleanly.');
+      process.exit(0);
+    });
+
+    setTimeout(() => {
+      console.error('[jenga-api] Forced exit after 5s timeout.');
+      process.exit(1);
+    }, FORCE_EXIT_MS).unref();
+  }
+
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+  process.on('SIGINT',  () => shutdown('SIGINT'));
+}
+
+module.exports = { app, registerShutdownHandlers, attachFallbackRoutes };