@creezio/observability 0.22.0

package/fleet-collector/test-server-admin.mjs

@@ -0,0 +1,475 @@
+/**
+ * Tests locaux du Creezio Server Admin (spawn serveur éphémère).
+ *
+ * Ne requiert PAS docker : CREEZIO_DOCKER_SOCK pointe sur un chemin
+ * inexistant → état docker "unknown" attendu pour les instances du registre.
+ */
+import http from "node:http";
+import net from "node:net";
+import { spawn } from "node:child_process";
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+import assert from "node:assert/strict";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ADMIN_USER = "admin";
+const ADMIN_PASS = "test-admin-pass";
+const BASIC =
+  "Basic " + Buffer.from(`${ADMIN_USER}:${ADMIN_PASS}`).toString("base64");
+
+// Port éphémère : réservé par l'OS puis libéré pour le serveur admin.
+function ephemeralPort() {
+  return new Promise((resolve, reject) => {
+    const srv = net.createServer();
+    srv.listen(0, "127.0.0.1", () => {
+      const p = srv.address().port;
+      srv.close(() => resolve(p));
+    });
+    srv.on("error", reject);
+  });
+}
+const PORT = await ephemeralPort();
+// Ports des instances fixture : éphémères aussi (aucun vrai serveur ne doit
+// écouter dessus — le test attend un 504 sur le proxy boot-status).
+const INSTANCE_PORT_1 = await ephemeralPort();
+const INSTANCE_PORT_2 = await ephemeralPort();
+
+// Fixture : brandRoot avec registre servers.json (2 instances).
+const TMP = fs.mkdtempSync(path.join(os.tmpdir(), "creezio-server-admin-"));
+const BRAND_ROOT = path.join(TMP, "testbrand");
+fs.mkdirSync(path.join(BRAND_ROOT, "docker-data", "servers", "demo"), {
+  recursive: true,
+});
+fs.writeFileSync(
+  path.join(BRAND_ROOT, "package.json"),
+  JSON.stringify({ name: "@creezio/app-testbrand" }, null, 2),
+);
+fs.writeFileSync(
+  path.join(BRAND_ROOT, "docker-data", "servers.json"),
+  JSON.stringify(
+    {
+      version: 1,
+      brandId: "testbrand",
+      image: "creezio-server-testbrand:local",
+      instances: [
+        {
+          name: "demo",
+          containerName: "testbrand-server-demo",
+          port: INSTANCE_PORT_1,
+          bind: "127.0.0.1",
+          dataDir: "docker-data/servers/demo",
+          createdAt: "2026-08-04T00:00:00.000Z",
+          env: { CREEZIO_NATIVE_WARM: "1" },
+        },
+        {
+          name: "second",
+          containerName: "testbrand-server-second",
+          port: INSTANCE_PORT_2,
+          bind: "127.0.0.1",
+          dataDir: "docker-data/servers/second",
+          createdAt: "2026-08-04T00:00:00.000Z",
+        },
+      ],
+    },
+    null,
+    2,
+  ),
+);
+// Événements ops JSONL pour l'instance demo.
+const opsDir = path.join(BRAND_ROOT, "docker-data", "servers", "demo", "ops");
+fs.mkdirSync(opsDir, { recursive: true });
+fs.writeFileSync(
+  path.join(opsDir, "boot-test.jsonl"),
+  [
+    JSON.stringify({ ts: "2026-08-04T00:00:01Z", kind: "boot.start", seq: 1 }),
+    JSON.stringify({ ts: "2026-08-04T00:00:02Z", kind: "boot.done", seq: 2 }),
+    "ligne invalide pas du json",
+  ].join("\n") + "\n",
+);
+
+function req(method, urlPath, body, headers = {}) {
+  return new Promise((resolve, reject) => {
+    const r = http.request(
+      {
+        hostname: "127.0.0.1",
+        port: PORT,
+        path: urlPath,
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          ...(body ? { "Content-Length": Buffer.byteLength(body) } : {}),
+          ...headers,
+        },
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => {
+          const raw = Buffer.concat(chunks).toString("utf8");
+          let json = null;
+          try {
+            json = raw ? JSON.parse(raw) : null;
+          } catch {
+            json = raw;
+          }
+          resolve({ status: res.statusCode, json, raw });
+        });
+      },
+    );
+    r.on("error", reject);
+    if (body) r.write(body);
+    r.end();
+  });
+}
+
+const child = spawn(
+  process.execPath,
+  // SoT @creezio/fleet (les wrappers .mjs de compat ont été retirés en 0.19) —
+  // exige le dist construit : npm run build -w @creezio/fleet.
+  [
+    path.join(
+      __dirname,
+      "../../fleet/dist/bin/server-admin-main.js",
+    ),
+  ],
+  {
+    env: {
+      ...process.env,
+      CREEZIO_ADMIN_PORT: String(PORT),
+      CREEZIO_ADMIN_HOST: "127.0.0.1",
+      CREEZIO_ADMIN_USER: ADMIN_USER,
+      CREEZIO_ADMIN_PASS: ADMIN_PASS,
+      CREEZIO_ADMIN_BRAND_ROOTS: BRAND_ROOT,
+      // Socket inexistant → docker indisponible (le test n'exige PAS docker).
+      CREEZIO_DOCKER_SOCK: path.join(TMP, "nonexistent-docker.sock"),
+    },
+    stdio: ["ignore", "pipe", "pipe"],
+  },
+);
+
+// Readiness : poll (un sleep fixe flake quand la machine est chargée).
+{
+  const deadline = Date.now() + 10_000;
+  for (;;) {
+    try {
+      await req("GET", "/admin/api/health", null, { Authorization: BASIC });
+      break;
+    } catch {
+      if (Date.now() > deadline) throw new Error("admin pas prêt en 10s");
+      await new Promise((r) => setTimeout(r, 150));
+    }
+  }
+}
+
+try {
+  // 401 sans auth (UI + API).
+  const unauthUi = await req("GET", "/admin");
+  assert.equal(unauthUi.status, 401);
+  assert.ok(
+    String(unauthUi.raw).includes("unauthorized") ||
+      unauthUi.json?.error === "unauthorized",
+  );
+  const unauthApi = await req("GET", "/admin/api/servers");
+  assert.equal(unauthApi.status, 401);
+  const badCreds = await req("GET", "/admin/api/servers", null, {
+    Authorization:
+      "Basic " + Buffer.from(`${ADMIN_USER}:wrong`).toString("base64"),
+  });
+  assert.equal(badCreds.status, 401);
+
+  // 200 + HTML sur /admin avec Basic auth.
+  const ui = await req("GET", "/admin", null, { Authorization: BASIC });
+  assert.equal(ui.status, 200);
+  assert.ok(String(ui.raw).includes("<!DOCTYPE html>"));
+  assert.ok(String(ui.raw).includes("Creezio Server Admin"));
+
+  // Health.
+  const health = await req("GET", "/admin/api/health", null, {
+    Authorization: BASIC,
+  });
+  assert.equal(health.status, 200);
+  assert.equal(health.json.ok, true);
+  assert.equal(health.json.service, "creezio-server-admin");
+  assert.deepEqual(health.json.brandRoots, [BRAND_ROOT]);
+  assert.equal(health.json.docker, false);
+
+  // Servers : instances du registre, état docker "unknown" (docker absent).
+  const servers = await req("GET", "/admin/api/servers", null, {
+    Authorization: BASIC,
+  });
+  assert.equal(servers.status, 200);
+  assert.equal(servers.json.ok, true);
+  assert.equal(servers.json.docker, false);
+  assert.equal(servers.json.servers.length, 2);
+  const demo = servers.json.servers.find((s) => s.name === "demo");
+  assert.ok(demo, "instance demo présente");
+  assert.equal(demo.brandId, "testbrand");
+  assert.equal(demo.containerName, "testbrand-server-demo");
+  assert.equal(demo.port, INSTANCE_PORT_1);
+  assert.equal(demo.orphan, false);
+  assert.equal(demo.docker.state, "unknown");
+  assert.equal(demo.bootStatus, null);
+  assert.equal(demo.env.CREEZIO_NATIVE_WARM, "1");
+  const second = servers.json.servers.find((s) => s.name === "second");
+  assert.equal(second.docker.state, "unknown");
+
+  // Snapshot flotte (F1) : refreshedAt présent, snapshot servi tel quel
+  // (2e appel immédiat = même refreshedAt), ?fresh=1 = collecte immédiate.
+  assert.ok(servers.json.refreshedAt, "refreshedAt attendu sur /servers");
+  const serversAgain = await req("GET", "/admin/api/servers", null, {
+    Authorization: BASIC,
+  });
+  assert.equal(
+    serversAgain.json.refreshedAt,
+    servers.json.refreshedAt,
+    "sans fresh=1 le snapshot est servi tel quel (pas de recollecte)",
+  );
+  await new Promise((r) => setTimeout(r, 15));
+  const serversFresh = await req("GET", "/admin/api/servers?fresh=1", null, {
+    Authorization: BASIC,
+  });
+  assert.equal(serversFresh.status, 200);
+  assert.equal(serversFresh.json.servers.length, 2);
+  assert.ok(
+    serversFresh.json.refreshedAt > servers.json.refreshedAt,
+    "?fresh=1 force une collecte immédiate (refreshedAt avance)",
+  );
+
+  // Hosts : snapshot + refreshedAt (aucun hôte enrôlé dans la fixture).
+  const hosts = await req("GET", "/admin/api/hosts", null, {
+    Authorization: BASIC,
+  });
+  assert.equal(hosts.status, 200);
+  assert.equal(hosts.json.ok, true);
+  assert.deepEqual(hosts.json.hosts, []);
+  assert.ok(hosts.json.refreshedAt, "refreshedAt attendu sur /hosts");
+
+  // Ops JSONL : événements parsés, lignes invalides ignorées.
+  const ops = await req(
+    "GET",
+    "/admin/api/servers/testbrand/demo/ops?limit=100",
+    null,
+    { Authorization: BASIC },
+  );
+  assert.equal(ops.status, 200);
+  assert.equal(ops.json.ok, true);
+  assert.equal(ops.json.events.length, 2);
+  assert.equal(ops.json.events[0].kind, "boot.start");
+  // Instance sans ops/ → vide, pas d'erreur.
+  const opsEmpty = await req(
+    "GET",
+    "/admin/api/servers/testbrand/second/ops",
+    null,
+    { Authorization: BASIC },
+  );
+  assert.equal(opsEmpty.status, 200);
+  assert.deepEqual(opsEmpty.json.events, []);
+
+  // Disk : tailles par instance + filesystem.
+  const disk = await req("GET", "/admin/api/disk", null, {
+    Authorization: BASIC,
+  });
+  assert.equal(disk.status, 200);
+  assert.equal(disk.json.ok, true);
+  assert.equal(disk.json.instances.length, 2);
+  assert.ok(
+    disk.json.instances.find((d) => d.name === "demo").sizeBytes > 0,
+    "taille data demo > 0 (fixtures ops)",
+  );
+  assert.ok(disk.json.filesystem.freeBytes > 0);
+  assert.ok(disk.json.refreshedAt, "refreshedAt attendu sur /disk");
+  await new Promise((r) => setTimeout(r, 15));
+  const diskFresh = await req("GET", "/admin/api/disk?fresh=1", null, {
+    Authorization: BASIC,
+  });
+  assert.equal(diskFresh.status, 200);
+  assert.ok(
+    diskFresh.json.refreshedAt > disk.json.refreshedAt,
+    "?fresh=1 force un scan disque immédiat",
+  );
+
+  // Instance inconnue → 404.
+  const notFound = await req(
+    "GET",
+    "/admin/api/servers/testbrand/nope/ops",
+    null,
+    { Authorization: BASIC },
+  );
+  assert.equal(notFound.status, 404);
+
+  // Create : brandRoot hors CREEZIO_ADMIN_BRAND_ROOTS refusé.
+  const badRoot = await req(
+    "POST",
+    "/admin/api/servers",
+    JSON.stringify({ brandRoot: "/etc", name: "evil" }),
+    { Authorization: BASIC },
+  );
+  assert.equal(badRoot.status, 400);
+  // Create : nom invalide refusé.
+  const badName = await req(
+    "POST",
+    "/admin/api/servers",
+    JSON.stringify({ brandRoot: BRAND_ROOT, name: "Bad_Name!" }),
+    { Authorization: BASIC },
+  );
+  assert.equal(badName.status, 400);
+  // Create : nom déjà pris → 409 (avant tout appel docker).
+  const dup = await req(
+    "POST",
+    "/admin/api/servers",
+    JSON.stringify({ brandRoot: BRAND_ROOT, name: "demo" }),
+    { Authorization: BASIC },
+  );
+  assert.equal(dup.status, 409);
+
+  // Boot-status proxy : serveur injoignable → 504.
+  const bs = await req(
+    "GET",
+    "/admin/api/servers/testbrand/demo/boot-status",
+    null,
+    { Authorization: BASIC },
+  );
+  assert.equal(bs.status, 504);
+
+  // 0 domaine marque hardcodé dans l'UI admin servie (SoT fleet + collector).
+  const src =
+    fs.readFileSync(
+      path.join(__dirname, "../../fleet/public/admin.html"),
+      "utf8",
+    ) + fs.readFileSync(path.join(__dirname, "public", "admin.html"), "utf8");
+  assert.ok(!/tempoflow\.fr|certivan\.creez\.io/i.test(src));
+
+  console.log("OK — server-admin (@creezio/observability)");
+} finally {
+  child.kill("SIGTERM");
+  try {
+    fs.rmSync(TMP, { recursive: true, force: true });
+  } catch {
+    /* ignore */
+  }
+}
+
+// ── backupInstanceData : archive vérifiée (gzip -t), jamais de warning
+// silencieux. Piège vécu : GNU tar exit 1 (« file changed as we read it »)
+// sur volume vivant = archive VALIDE, l'ancien code la jetait en
+// « backup indisponible (tar) » alors que le .tar.gz complet existait.
+{
+  const { backupInstanceData, backupsDir } = await import("./server-lib.mjs");
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "creezio-backup-"));
+  try {
+    const brandRoot = path.join(tmp, "brand");
+    const dataDir = path.join("docker-data", "servers", "demo");
+    fs.mkdirSync(path.join(brandRoot, dataDir, "sub"), { recursive: true });
+    fs.writeFileSync(
+      path.join(brandRoot, dataDir, "sub", "core.db"),
+      "contenu-test",
+    );
+    const inst = { name: "demo", dataDir };
+
+    const ok = await backupInstanceData(brandRoot, inst);
+    assert.equal(ok.ok, true, `backup attendu OK: ${ok.detail}`);
+    assert.ok(fs.existsSync(ok.file), "archive .tar.gz absente");
+    assert.ok(fs.statSync(ok.file).size > 0, "archive vide");
+    assert.match(ok.detail, /gzip vérifié/);
+    assert.ok(ok.file.startsWith(backupsDir(brandRoot)));
+
+    // Volume introuvable → échec PROPRE avec détail (pas de null muet).
+    const ko = await backupInstanceData(brandRoot, {
+      name: "fantome",
+      dataDir: path.join("docker-data", "servers", "fantome"),
+    });
+    assert.equal(ko.ok, false);
+    assert.match(ko.detail, /introuvable/);
+    console.log("OK — backupInstanceData (archive gzip vérifiée)");
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+// ── updateServer : défaut backup=false, pas de prune des archives existantes
+{
+  const { updateServer } = await import("./server-lib.mjs");
+  // P2.b : server-lib.mjs est un wrapper compat — lire la source RÉELLE
+  // (dist @creezio/fleet, résolu comme à l'exécution).
+  const src = fs.readFileSync(
+    new URL(import.meta.resolve("@creezio/fleet/server-lib")),
+    "utf8",
+  );
+  assert.match(src, /backup = false/);
+  assert.match(src, /pas de nouveau backup \(défaut\)/);
+  assert.match(src, /if \(backup\)/);
+  // Politique propriétaire : ne pas purger les backups de référence à l'update.
+  assert.doesNotMatch(src, /pruneBackups\(brandRoot, inst\.name\)/);
+  // 0.10.3 : update ne droppe plus un sidecar / hostname public.
+  assert.match(src, /resolveStackUpdatePolicy/);
+  assert.match(src, /preserve-sidecar/);
+  assert.equal(typeof updateServer, "function");
+  console.log("OK — updateServer défaut sans backup + archives conservées");
+}
+
+// ── dirSizeBytes / buildDiskReport asynchrones (F1) : fs.promises, plus de
+// readdirSync/statSync récursifs qui gèlent l'event loop mono-thread.
+{
+  const { dirSizeBytes, buildDiskReport } = await import("./server-lib.mjs");
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "creezio-disk-"));
+  try {
+    fs.mkdirSync(path.join(tmp, "sub"), { recursive: true });
+    fs.writeFileSync(path.join(tmp, "a.bin"), "12345");
+    fs.writeFileSync(path.join(tmp, "sub", "b.bin"), "1234567890");
+    const p = dirSizeBytes(tmp);
+    assert.ok(p instanceof Promise, "dirSizeBytes doit être asynchrone");
+    assert.equal(await p, 15);
+    const report = buildDiskReport([]);
+    assert.ok(report instanceof Promise, "buildDiskReport doit être asynchrone");
+    assert.equal((await report).ok, true);
+    console.log("OK — dirSizeBytes/buildDiskReport async");
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+// ── createFleetSnapshotPoller (F1) : jamais réentrant (cycle en cours
+// réutilisé), refresh forcé après cycle, scan disque séparé.
+{
+  const { createFleetSnapshotPoller } = await import("./server-lib.mjs");
+  let coreCalls = 0;
+  let diskCalls = 0;
+  let release;
+  const gate = new Promise((r) => (release = r));
+  const poller = createFleetSnapshotPoller({
+    collectServersView: async () => {
+      coreCalls += 1;
+      await gate;
+      return { docker: true, servers: [{ name: "x" }] };
+    },
+    collectHostsView: async () => [{ hostId: "h1" }],
+    collectDiskView: async () => {
+      diskCalls += 1;
+      return { ok: true, instances: [], filesystem: null };
+    },
+    intervalMs: 3_600_000,
+  });
+  // 3 refresh concurrents pendant qu'un cycle est en cours → 1 seule collecte.
+  const p1 = poller.refreshCore();
+  const p2 = poller.refreshCore();
+  const p3 = poller.refreshCore();
+  assert.equal(coreCalls, 1, "cycle en cours réutilisé (jamais réentrant)");
+  release();
+  await Promise.all([p1, p2, p3]);
+  assert.equal(coreCalls, 1);
+  assert.equal(poller.snapshot.servers.docker, true);
+  assert.deepEqual(poller.snapshot.hosts, [{ hostId: "h1" }]);
+  assert.ok(poller.snapshot.refreshedAt);
+  // Cycle terminé : un nouveau refresh relance bien une collecte.
+  await poller.refreshCore();
+  assert.equal(coreCalls, 2);
+  // Scan disque indépendant du cycle core (cadence 1/N côté poller).
+  assert.equal(diskCalls, 0);
+  await poller.refreshDisk();
+  assert.equal(diskCalls, 1);
+  assert.ok(poller.snapshot.diskRefreshedAt);
+  poller.stop();
+  console.log("OK — createFleetSnapshotPoller (non réentrant, snapshot)");
+}

package/package.json

@@ -0,0 +1,109 @@
+{
+  "name": "@creezio/observability",
+  "version": "0.22.0",
+  "description": "Observabilité — activité/CP + ops/fleet + fleet-collector (P25) + usage analytics (N6) + request-logs admin (O5)",
+  "type": "module",
+  "main": "./dist-cjs/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "creezio-fleet-collector": "./fleet-collector/server.mjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist-cjs/index.js",
+      "default": "./dist/index.js"
+    },
+    "./ui": {
+      "types": "./ui/index.ts",
+      "import": "./ui/index.ts",
+      "default": "./ui/index.ts"
+    },
+    "./fleet-collector/*": "./fleet-collector/*"
+  },
+  "files": [
+    "dist",
+    "dist-cjs",
+    "ui",
+    "fleet-collector",
+    "scripts"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.cjs.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "fleet-collector": "node fleet-collector/server.mjs",
+    "test:fleet-collector": "node fleet-collector/test-fleet-collector.mjs",
+    "test:server-admin": "node fleet-collector/test-server-admin.mjs",
+    "test:api-endpoints": "node scripts/test-api-endpoints-registry.mjs"
+  },
+  "dependencies": {
+    "@creezio/api-kernel": "^0.22.0",
+    "@creezio/fleet": "^0.22.0",
+    "@creezio/platform-core": "^0.22.0",
+    "hono": "^4.12.32"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.3",
+    "@types/react": "^18.3.12",
+    "typescript": "^5.8.3"
+  },
+  "license": "UNLICENSED",
+  "module": "./dist/index.js",
+  "peerDependencies": {
+    "@creezio/auth": ">=0.4.0",
+    "@radix-ui/react-slot": "^1.1.0",
+    "@radix-ui/react-tabs": "^1.1.0",
+    "class-variance-authority": "^0.7.0",
+    "clsx": "^2.0.0",
+    "lucide-react": ">=0.400.0",
+    "next": ">=14.0.0",
+    "react": "^18.0.0 || ^19.0.0",
+    "recharts": ">=2.0.0",
+    "tailwind-merge": "^2.0.0 || ^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@creezio/auth": {
+      "optional": true
+    },
+    "@radix-ui/react-slot": {
+      "optional": true
+    },
+    "@radix-ui/react-tabs": {
+      "optional": true
+    },
+    "class-variance-authority": {
+      "optional": true
+    },
+    "clsx": {
+      "optional": true
+    },
+    "lucide-react": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "recharts": {
+      "optional": true
+    },
+    "tailwind-merge": {
+      "optional": true
+    },
+    "next": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/creezio/creezio.git",
+    "directory": "packages/observability"
+  },
+  "engines": {
+    "node": ">=22.5"
+  }
+}

package/scripts/test-api-endpoints-registry.mjs

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+/**
+ * Smoke O5 — buildApiEndpointsRegistry + createApiEndpointsRoutes.
+ */
+import assert from "node:assert/strict";
+import { Hono } from "hono";
+import {
+  buildApiEndpointsRegistry,
+  collectHonoRoutes,
+  createApiEndpointsRoutes,
+} from "../dist/api-endpoints/index.js";
+
+const openapi = {
+  paths: {
+    "/api/v1/health": {
+      get: {
+        summary: "Health",
+        tags: ["core"],
+      },
+    },
+  },
+};
+
+const registry = buildApiEndpointsRegistry({
+  routes: [
+    { method: "GET", path: "/api/v1/health" },
+    { method: "POST", path: "/api/v1/notes" },
+    { method: "GET", path: "/api/v1/health" }, // dedupe
+  ],
+  openApiDocument: openapi,
+  source: "test",
+});
+
+assert.equal(registry.endpoints.length, 2);
+assert.equal(registry.endpoints[0].path, "/api/v1/health");
+assert.equal(registry.endpoints[0].documented, true);
+assert.equal(registry.endpoints[0].summary, "Health");
+assert.equal(registry.endpoints[1].documented, false);
+
+const app = new Hono();
+app.get("/ping", (c) => c.json({ ok: true }));
+app.route(
+  "/",
+  createApiEndpointsRoutes({
+    getRegistry: () =>
+      buildApiEndpointsRegistry({
+        routes: collectHonoRoutes(app, "/api/v1/admin"),
+        source: "hono-test",
+      }),
+  }),
+);
+
+const res = await app.request("http://local/endpoints");
+assert.equal(res.status, 200);
+const body = await res.json();
+assert.ok(Array.isArray(body.endpoints));
+assert.ok(body.endpoints.some((e) => e.path.endsWith("/ping")));
+assert.ok(body.endpoints.some((e) => e.path.endsWith("/endpoints")));
+
+console.log("OK test-api-endpoints-registry");