@http-client-toolkit/dashboard 0.1.0

package/lib/index.cjs

@@ -0,0 +1,1150 @@
+'use strict';
+
+var zod = require('zod');
+var fs = require('fs');
+var path = require('path');
+var url = require('url');
+var http = require('http');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// src/adapters/cache/generic.ts
+function createGenericCacheAdapter(store) {
+  return {
+    type: "generic",
+    capabilities: {
+      canList: false,
+      canDelete: true,
+      canClear: true,
+      canGetStats: false
+    },
+    async getStats() {
+      return { message: "Stats not available for this store type" };
+    },
+    async listEntries() {
+      return { entries: [] };
+    },
+    async getEntry(hash) {
+      return store.get(hash);
+    },
+    async deleteEntry(hash) {
+      await store.delete(hash);
+    },
+    async clearAll() {
+      await store.clear();
+    }
+  };
+}
+
+// src/adapters/cache/memory.ts
+function createMemoryCacheAdapter(store) {
+  const memStore = store;
+  return {
+    type: "memory",
+    capabilities: {
+      canList: true,
+      canDelete: true,
+      canClear: true,
+      canGetStats: true
+    },
+    async getStats() {
+      return memStore.getStats();
+    },
+    async listEntries(page, limit) {
+      const offset = page * limit;
+      const entries = memStore.listEntries(offset, limit);
+      return { entries };
+    },
+    async getEntry(hash) {
+      return memStore.get(hash);
+    },
+    async deleteEntry(hash) {
+      await memStore.delete(hash);
+    },
+    async clearAll() {
+      await memStore.clear();
+    }
+  };
+}
+
+// src/adapters/cache/sqlite.ts
+function createSqliteCacheAdapter(store) {
+  const sqlStore = store;
+  return {
+    type: "sqlite",
+    capabilities: {
+      canList: true,
+      canDelete: true,
+      canClear: true,
+      canGetStats: true
+    },
+    async getStats() {
+      return sqlStore.getStats();
+    },
+    async listEntries(page, limit) {
+      const offset = page * limit;
+      const results = await sqlStore.listEntries(offset, limit);
+      const entries = results.map((r) => ({
+        hash: r.hash,
+        expiresAt: r.expiresAt,
+        createdAt: r.createdAt
+      }));
+      return { entries };
+    },
+    async getEntry(hash) {
+      return sqlStore.get(hash);
+    },
+    async deleteEntry(hash) {
+      await sqlStore.delete(hash);
+    },
+    async clearAll() {
+      await sqlStore.clear();
+    }
+  };
+}
+
+// src/adapters/dedup/generic.ts
+function createGenericDedupeAdapter(_store) {
+  return {
+    type: "generic",
+    capabilities: {
+      canList: false,
+      canGetStats: false
+    },
+    async getStats() {
+      return { message: "Stats not available for this store type" };
+    },
+    async listJobs() {
+      return { jobs: [] };
+    },
+    async getJob() {
+      return void 0;
+    }
+  };
+}
+
+// src/adapters/dedup/memory.ts
+function createMemoryDedupeAdapter(store) {
+  const memStore = store;
+  return {
+    type: "memory",
+    capabilities: {
+      canList: true,
+      canGetStats: true
+    },
+    async getStats() {
+      return memStore.getStats();
+    },
+    async listJobs(page, limit) {
+      const offset = page * limit;
+      const jobs = memStore.listJobs(offset, limit);
+      return { jobs };
+    },
+    async getJob(hash) {
+      const jobs = memStore.listJobs(0, 1e3);
+      return jobs.find((j) => j.hash === hash);
+    }
+  };
+}
+
+// src/adapters/dedup/sqlite.ts
+function createSqliteDedupeAdapter(store) {
+  const sqlStore = store;
+  return {
+    type: "sqlite",
+    capabilities: {
+      canList: true,
+      canGetStats: true
+    },
+    async getStats() {
+      return sqlStore.getStats();
+    },
+    async listJobs(page, limit) {
+      const offset = page * limit;
+      const results = await sqlStore.listJobs(offset, limit);
+      return { jobs: results };
+    },
+    async getJob(hash) {
+      const results = await sqlStore.listJobs(0, 1e3);
+      return results.find((j) => j.hash === hash);
+    }
+  };
+}
+
+// src/adapters/rate-limit/generic.ts
+function createGenericRateLimitAdapter(store) {
+  return {
+    type: "generic",
+    capabilities: {
+      canList: false,
+      canGetStats: false,
+      canUpdateConfig: false,
+      canReset: true
+    },
+    async getStats() {
+      return { message: "Stats not available for this store type" };
+    },
+    async listResources() {
+      return [];
+    },
+    async getResourceStatus(name) {
+      return store.getStatus(name);
+    },
+    async updateResourceConfig() {
+      throw new Error("Config updates not supported for this store type");
+    },
+    async resetResource(name) {
+      await store.reset(name);
+    }
+  };
+}
+
+// src/adapters/rate-limit/memory.ts
+function createMemoryRateLimitAdapter(store) {
+  const memStore = store;
+  return {
+    type: "memory",
+    capabilities: {
+      canList: true,
+      canGetStats: true,
+      canUpdateConfig: true,
+      canReset: true
+    },
+    async getStats() {
+      return memStore.getStats();
+    },
+    async listResources() {
+      return memStore.listResources();
+    },
+    async getResourceStatus(name) {
+      return memStore.getStatus(name);
+    },
+    async updateResourceConfig(name, config) {
+      memStore.setResourceConfig(name, config);
+    },
+    async resetResource(name) {
+      await memStore.reset(name);
+    }
+  };
+}
+
+// src/adapters/rate-limit/sqlite.ts
+function createSqliteRateLimitAdapter(store) {
+  const sqlStore = store;
+  return {
+    type: "sqlite",
+    capabilities: {
+      canList: true,
+      canGetStats: true,
+      canUpdateConfig: true,
+      canReset: true
+    },
+    async getStats() {
+      return sqlStore.getStats();
+    },
+    async listResources() {
+      return sqlStore.listResources();
+    },
+    async getResourceStatus(name) {
+      return sqlStore.getStatus(name);
+    },
+    async updateResourceConfig(name, config) {
+      sqlStore.setResourceConfig(name, config);
+    },
+    async resetResource(name) {
+      await sqlStore.reset(name);
+    }
+  };
+}
+
+// src/adapters/detect.ts
+function isMemoryStore(store) {
+  if (!store || typeof store !== "object") return false;
+  const s = store;
+  return typeof s.destroy === "function" && typeof s.getStats === "function" && typeof s.cleanup === "function" && typeof s.getLRUItems === "function";
+}
+function isSqliteStore(store) {
+  if (!store || typeof store !== "object") return false;
+  const s = store;
+  return typeof s.destroy === "function" && typeof s.getStats === "function" && typeof s.close === "function";
+}
+function isMemoryDedupeStore(store) {
+  if (!store || typeof store !== "object") return false;
+  const s = store;
+  return typeof s.destroy === "function" && typeof s.getStats === "function" && typeof s.listJobs === "function" && typeof s.cleanup === "function" && !("close" in s && typeof s.close === "function");
+}
+function isSqliteDedupeStore(store) {
+  if (!store || typeof store !== "object") return false;
+  const s = store;
+  return typeof s.destroy === "function" && typeof s.getStats === "function" && typeof s.close === "function" && typeof s.listJobs === "function";
+}
+function isMemoryRateLimitStore(store) {
+  if (!store || typeof store !== "object") return false;
+  const s = store;
+  return typeof s.destroy === "function" && typeof s.getStats === "function" && typeof s.listResources === "function" && typeof s.setResourceConfig === "function" && !("close" in s && typeof s.close === "function");
+}
+function isSqliteRateLimitStore(store) {
+  if (!store || typeof store !== "object") return false;
+  const s = store;
+  return typeof s.destroy === "function" && typeof s.getStats === "function" && typeof s.close === "function" && typeof s.listResources === "function" && typeof s.setResourceConfig === "function";
+}
+function detectCacheAdapter(store) {
+  if (isMemoryStore(store)) {
+    return createMemoryCacheAdapter(store);
+  }
+  if (isSqliteStore(store)) {
+    return createSqliteCacheAdapter(store);
+  }
+  return createGenericCacheAdapter(store);
+}
+function detectDedupeAdapter(store) {
+  if (isMemoryDedupeStore(store)) {
+    return createMemoryDedupeAdapter(store);
+  }
+  if (isSqliteDedupeStore(store)) {
+    return createSqliteDedupeAdapter(store);
+  }
+  return createGenericDedupeAdapter();
+}
+function detectRateLimitAdapter(store) {
+  if (isMemoryRateLimitStore(store)) {
+    return createMemoryRateLimitAdapter(store);
+  }
+  if (isSqliteRateLimitStore(store)) {
+    return createSqliteRateLimitAdapter(store);
+  }
+  return createGenericRateLimitAdapter(store);
+}
+var CLIENT_NAME_REGEX = /^[a-zA-Z0-9_-]+$/;
+var ClientConfigSchema = zod.z.object({
+  name: zod.z.string().min(1, "Client name must not be empty").regex(
+    CLIENT_NAME_REGEX,
+    "Client name must be URL-safe (a-z, 0-9, -, _)"
+  ),
+  cacheStore: zod.z.custom().optional(),
+  dedupeStore: zod.z.custom().optional(),
+  rateLimitStore: zod.z.custom().optional()
+}).refine(
+  (data) => data.cacheStore || data.dedupeStore || data.rateLimitStore,
+  { message: "At least one store must be provided per client" }
+);
+var DashboardOptionsSchema = zod.z.object({
+  clients: zod.z.array(ClientConfigSchema).min(1, "At least one client is required"),
+  basePath: zod.z.string().default("/"),
+  pollIntervalMs: zod.z.number().int().positive().default(5e3)
+}).refine(
+  (data) => {
+    const names = data.clients.map((c) => c.name);
+    return new Set(names).size === names.length;
+  },
+  { message: "Client names must be unique" }
+);
+var StandaloneDashboardOptionsSchema = DashboardOptionsSchema.and(
+  zod.z.object({
+    port: zod.z.number().int().nonnegative().default(4e3),
+    host: zod.z.string().default("localhost")
+  })
+);
+function validateDashboardOptions(options) {
+  return DashboardOptionsSchema.parse(options);
+}
+function validateStandaloneOptions(options) {
+  return StandaloneDashboardOptionsSchema.parse(options);
+}
+
+// src/server/request-helpers.ts
+function parseUrl(req, basePath) {
+  const raw = req.url ?? "/";
+  const url = new URL(raw, "http://localhost");
+  let pathname = url.pathname;
+  if (basePath !== "/" && pathname.startsWith(basePath)) {
+    pathname = pathname.slice(basePath.length) || "/";
+  }
+  return { pathname, query: url.searchParams };
+}
+function extractParam(pathname, pattern) {
+  const patternParts = pattern.split("/");
+  const pathParts = pathname.split("/");
+  if (patternParts.length !== pathParts.length) return void 0;
+  for (let i = 0; i < patternParts.length; i++) {
+    const pp = patternParts[i];
+    if (pp.startsWith(":")) continue;
+    if (pp !== pathParts[i]) return void 0;
+  }
+  const paramIndex = patternParts.findIndex((p) => p.startsWith(":"));
+  if (paramIndex === -1) return void 0;
+  return pathParts[paramIndex];
+}
+async function readJsonBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => {
+      try {
+        resolve(JSON.parse(body));
+      } catch {
+        reject(new Error("Invalid JSON body"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+// src/server/response-helpers.ts
+function sendJson(res, data, status = 200) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Content-Length": Buffer.byteLength(body),
+    "Cache-Control": "no-store"
+  });
+  res.end(body);
+}
+function sendError(res, message, status = 500) {
+  sendJson(res, { error: message }, status);
+}
+function sendNotFound(res) {
+  sendError(res, "Not found", 404);
+}
+function sendMethodNotAllowed(res) {
+  sendError(res, "Method not allowed", 405);
+}
+
+// src/server/handlers/cache.ts
+async function handleCacheStats(res, adapter) {
+  try {
+    const stats = await adapter.getStats();
+    sendJson(res, { stats, capabilities: adapter.capabilities });
+  } catch (err) {
+    sendError(res, err instanceof Error ? err.message : "Unknown error");
+  }
+}
+async function handleCacheEntries(_req, res, adapter, query) {
+  try {
+    const page = parseInt(query.get("page") ?? "0", 10);
+    const limit = parseInt(query.get("limit") ?? "50", 10);
+    const result = await adapter.listEntries(page, limit);
+    sendJson(res, result);
+  } catch (err) {
+    sendError(res, err instanceof Error ? err.message : "Unknown error");
+  }
+}
+async function handleCacheEntry(res, adapter, pathname) {
+  try {
+    const hash = extractParam(pathname, "/cache/entries/:hash");
+    if (!hash) {
+      sendNotFound(res);
+      return;
+    }
+    const entry = await adapter.getEntry(hash);
+    if (entry === void 0) {
+      sendNotFound(res);
+      return;
+    }
+    sendJson(res, { hash, value: entry });
+  } catch (err) {
+    sendError(res, err instanceof Error ? err.message : "Unknown error");
+  }
+}
+async function handleDeleteCacheEntry(res, adapter, pathname) {
+  try {
+    const hash = extractParam(pathname, "/cache/entries/:hash");
+    if (!hash) {
+      sendNotFound(res);
+      return;
+    }
+    await adapter.deleteEntry(hash);
+    sendJson(res, { deleted: true });
+  } catch (err) {
+    sendError(res, err instanceof Error ? err.message : "Unknown error");
+  }
+}
+async function handleClearCache(res, adapter) {
+  try {
+    await adapter.clearAll();
+    sendJson(res, { cleared: true });
+  } catch (err) {
+    sendError(res, err instanceof Error ? err.message : "Unknown error");
+  }
+}
+
+// src/server/handlers/dedup.ts
+async function handleDedupeStats(res, adapter) {
+  try {
+    const stats = await adapter.getStats();
+    sendJson(res, { stats, capabilities: adapter.capabilities });
+  } catch (err) {
+    sendError(res, err instanceof Error ? err.message : "Unknown error");
+  }
+}
+async function handleDedupeJobs(_req, res, adapter, query) {
+  try {
+    const page = parseInt(query.get("page") ?? "0", 10);
+    const limit = parseInt(query.get("limit") ?? "50", 10);
+    const result = await adapter.listJobs(page, limit);
+    sendJson(res, result);
+  } catch (err) {
+    sendError(res, err instanceof Error ? err.message : "Unknown error");
+  }
+}
+async function handleDedupeJob(res, adapter, pathname) {
+  try {
+    const hash = extractParam(pathname, "/dedup/jobs/:hash");
+    if (!hash) {
+      sendNotFound(res);
+      return;
+    }
+    const job = await adapter.getJob(hash);
+    if (!job) {
+      sendNotFound(res);
+      return;
+    }
+    sendJson(res, job);
+  } catch (err) {
+    sendError(res, err instanceof Error ? err.message : "Unknown error");
+  }
+}
+
+// src/server/handlers/health.ts
+function clientStoreInfo(client) {
+  return {
+    cache: client.cache ? { type: client.cache.type, capabilities: client.cache.capabilities } : null,
+    dedup: client.dedup ? { type: client.dedup.type, capabilities: client.dedup.capabilities } : null,
+    rateLimit: client.rateLimit ? {
+      type: client.rateLimit.type,
+      capabilities: client.rateLimit.capabilities
+    } : null
+  };
+}
+function handleHealth(res, ctx) {
+  const clients = {};
+  for (const [name, client] of ctx.clients) {
+    clients[name] = clientStoreInfo(client);
+  }
+  sendJson(res, {
+    status: "ok",
+    clients,
+    pollIntervalMs: ctx.pollIntervalMs
+  });
+}
+
+// src/server/handlers/rate-limit.ts
+async function handleRateLimitStats(res, adapter) {
+  try {
+    const stats = await adapter.getStats();
+    sendJson(res, { stats, capabilities: adapter.capabilities });
+  } catch (err) {
+    sendError(res, err instanceof Error ? err.message : "Unknown error");
+  }
+}
+async function handleRateLimitResources(res, adapter) {
+  try {
+    const resources = await adapter.listResources();
+    sendJson(res, { resources });
+  } catch (err) {
+    sendError(res, err instanceof Error ? err.message : "Unknown error");
+  }
+}
+async function handleRateLimitResource(res, adapter, pathname) {
+  try {
+    const name = extractParam(pathname, "/rate-limit/resources/:name");
+    if (!name) {
+      sendNotFound(res);
+      return;
+    }
+    const status = await adapter.getResourceStatus(name);
+    sendJson(res, { resource: name, ...status });
+  } catch (err) {
+    sendError(res, err instanceof Error ? err.message : "Unknown error");
+  }
+}
+async function handleUpdateRateLimitConfig(req, res, adapter, pathname) {
+  try {
+    const name = extractParam(pathname, "/rate-limit/resources/:name/config");
+    if (!name) {
+      sendNotFound(res);
+      return;
+    }
+    const body = await readJsonBody(req);
+    await adapter.updateResourceConfig(name, body);
+    sendJson(res, { updated: true });
+  } catch (err) {
+    sendError(res, err instanceof Error ? err.message : "Unknown error");
+  }
+}
+async function handleResetRateLimitResource(res, adapter, pathname) {
+  try {
+    const name = extractParam(pathname, "/rate-limit/resources/:name/reset");
+    if (!name) {
+      sendNotFound(res);
+      return;
+    }
+    await adapter.resetResource(name);
+    sendJson(res, { reset: true });
+  } catch (err) {
+    sendError(res, err instanceof Error ? err.message : "Unknown error");
+  }
+}
+
+// src/server/handlers/stores.ts
+function handleClients(res, ctx) {
+  const clients = [];
+  for (const [name, client] of ctx.clients) {
+    clients.push({
+      name,
+      stores: {
+        cache: client.cache ? { type: client.cache.type, capabilities: client.cache.capabilities } : null,
+        dedup: client.dedup ? { type: client.dedup.type, capabilities: client.dedup.capabilities } : null,
+        rateLimit: client.rateLimit ? {
+          type: client.rateLimit.type,
+          capabilities: client.rateLimit.capabilities
+        } : null
+      }
+    });
+  }
+  sendJson(res, { clients });
+}
+
+// src/server/api-router.ts
+var CLIENT_ROUTE_REGEX = /^\/api\/clients\/([a-zA-Z0-9_-]+)(\/.*)?$/;
+function createApiRouter(ctx) {
+  return async (req, res, pathname, query) => {
+    const method = req.method?.toUpperCase() ?? "GET";
+    if (pathname === "/api/health" && method === "GET") {
+      handleHealth(res, ctx);
+      return true;
+    }
+    if (pathname === "/api/clients" && method === "GET") {
+      handleClients(res, ctx);
+      return true;
+    }
+    const clientMatch = pathname.match(CLIENT_ROUTE_REGEX);
+    if (clientMatch) {
+      const clientName = clientMatch[1];
+      const subPath = clientMatch[2] ?? "";
+      const client = ctx.clients.get(clientName);
+      if (!client) {
+        sendError(res, `Unknown client: ${clientName}`, 404);
+        return true;
+      }
+      return routeClientApi(req, res, client, subPath, method, query);
+    }
+    if (pathname.startsWith("/api/")) {
+      sendNotFound(res);
+      return true;
+    }
+    return false;
+  };
+}
+async function routeClientApi(req, res, client, subPath, method, query) {
+  if (subPath.startsWith("/cache")) {
+    if (!client.cache) {
+      sendError(res, "Cache store not configured", 404);
+      return true;
+    }
+    if (subPath === "/cache/stats" && method === "GET") {
+      await handleCacheStats(res, client.cache);
+      return true;
+    }
+    if (subPath === "/cache/entries" && method === "GET") {
+      await handleCacheEntries(req, res, client.cache, query);
+      return true;
+    }
+    if (subPath === "/cache/entries" && method === "DELETE") {
+      await handleClearCache(res, client.cache);
+      return true;
+    }
+    const isSingleEntry = subPath.startsWith("/cache/entries/") && subPath.split("/").length === 4;
+    if (isSingleEntry && method === "GET") {
+      await handleCacheEntry(res, client.cache, subPath);
+      return true;
+    }
+    if (isSingleEntry && method === "DELETE") {
+      await handleDeleteCacheEntry(res, client.cache, subPath);
+      return true;
+    }
+    if (isSingleEntry) {
+      sendMethodNotAllowed(res);
+      return true;
+    }
+  }
+  if (subPath.startsWith("/dedup")) {
+    if (!client.dedup) {
+      sendError(res, "Dedup store not configured", 404);
+      return true;
+    }
+    if (subPath === "/dedup/stats" && method === "GET") {
+      await handleDedupeStats(res, client.dedup);
+      return true;
+    }
+    if (subPath === "/dedup/jobs" && method === "GET") {
+      await handleDedupeJobs(req, res, client.dedup, query);
+      return true;
+    }
+    const isSingleJob = subPath.startsWith("/dedup/jobs/") && subPath.split("/").length === 4;
+    if (isSingleJob && method === "GET") {
+      await handleDedupeJob(res, client.dedup, subPath);
+      return true;
+    }
+    if (isSingleJob) {
+      sendMethodNotAllowed(res);
+      return true;
+    }
+  }
+  if (subPath.startsWith("/rate-limit")) {
+    if (!client.rateLimit) {
+      sendError(res, "Rate limit store not configured", 404);
+      return true;
+    }
+    if (subPath === "/rate-limit/stats" && method === "GET") {
+      await handleRateLimitStats(res, client.rateLimit);
+      return true;
+    }
+    if (subPath === "/rate-limit/resources" && method === "GET") {
+      await handleRateLimitResources(res, client.rateLimit);
+      return true;
+    }
+    if (subPath.endsWith("/config") && method === "PUT") {
+      await handleUpdateRateLimitConfig(req, res, client.rateLimit, subPath);
+      return true;
+    }
+    if (subPath.endsWith("/reset") && method === "POST") {
+      await handleResetRateLimitResource(res, client.rateLimit, subPath);
+      return true;
+    }
+    const isSingleResource = subPath.startsWith("/rate-limit/resources/") && subPath.split("/").length === 4;
+    if (isSingleResource && method === "GET") {
+      await handleRateLimitResource(res, client.rateLimit, subPath);
+      return true;
+    }
+    if (isSingleResource) {
+      sendMethodNotAllowed(res);
+      return true;
+    }
+  }
+  sendNotFound(res);
+  return true;
+}
+var MIME_TYPES = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+var cachedIndexHtml;
+var clientDir;
+function getCurrentDir() {
+  try {
+    return path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+  } catch {
+    return typeof __dirname !== "undefined" ? __dirname : process.cwd();
+  }
+}
+function getClientDir() {
+  if (clientDir) return clientDir;
+  const currentDir = getCurrentDir();
+  clientDir = path.join(currentDir, "..", "dist", "client");
+  return clientDir;
+}
+function getIndexHtml() {
+  if (cachedIndexHtml) return cachedIndexHtml;
+  const indexPath = path.join(getClientDir(), "index.html");
+  if (fs.existsSync(indexPath)) {
+    cachedIndexHtml = fs.readFileSync(indexPath, "utf-8");
+  } else {
+    cachedIndexHtml = `<!DOCTYPE html>
+<html lang="en">
+<head><meta charset="UTF-8"><title>Dashboard</title></head>
+<body>
+<div id="root">
+  <p style="font-family:sans-serif;text-align:center;margin-top:4rem">
+    Dashboard client not built. Run <code>vite build</code> first.
+  </p>
+</div>
+</body>
+</html>`;
+  }
+  return cachedIndexHtml;
+}
+function serveStatic(res, pathname) {
+  const dir = getClientDir();
+  if (pathname !== "/" && pathname !== "/index.html") {
+    const filePath = path.join(dir, pathname);
+    if (fs.existsSync(filePath)) {
+      try {
+        const content = fs.readFileSync(filePath);
+        const ext = path.extname(pathname);
+        const mimeType = MIME_TYPES[ext] ?? "application/octet-stream";
+        res.writeHead(200, {
+          "Content-Type": mimeType,
+          "Content-Length": content.length,
+          "Cache-Control": pathname.includes("/assets/") ? "public, max-age=31536000, immutable" : "no-cache"
+        });
+        res.end(content);
+        return true;
+      } catch {
+      }
+    }
+  }
+  const html = getIndexHtml();
+  res.writeHead(200, {
+    "Content-Type": "text/html",
+    "Content-Length": Buffer.byteLength(html),
+    "Cache-Control": "no-cache"
+  });
+  res.end(html);
+  return true;
+}
+
+// src/server/middleware.ts
+function createDashboard(options) {
+  const opts = validateDashboardOptions(options);
+  const clients = /* @__PURE__ */ new Map();
+  for (const clientConfig of opts.clients) {
+    clients.set(clientConfig.name, {
+      name: clientConfig.name,
+      cache: clientConfig.cacheStore ? detectCacheAdapter(clientConfig.cacheStore) : void 0,
+      dedup: clientConfig.dedupeStore ? detectDedupeAdapter(clientConfig.dedupeStore) : void 0,
+      rateLimit: clientConfig.rateLimitStore ? detectRateLimitAdapter(clientConfig.rateLimitStore) : void 0
+    });
+  }
+  const ctx = {
+    clients,
+    pollIntervalMs: opts.pollIntervalMs
+  };
+  const apiRouter = createApiRouter(ctx);
+  return (req, res, _next) => {
+    const { pathname, query } = parseUrl(req, opts.basePath);
+    apiRouter(req, res, pathname, query).then((handled) => {
+      if (!handled) {
+        serveStatic(res, pathname);
+      }
+    }).catch(() => {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Internal server error" }));
+    });
+  };
+}
+var JSON_HEADERS = {
+  "Content-Type": "application/json",
+  "Cache-Control": "no-store"
+};
+function jsonResponse(data, status = 200) {
+  return new Response(JSON.stringify(data), { status, headers: JSON_HEADERS });
+}
+function errorResponse(message, status = 500) {
+  return jsonResponse({ error: message }, status);
+}
+var MIME_TYPES2 = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+var cachedIndexHtml2;
+var clientDir2;
+function getCurrentDir2() {
+  try {
+    return path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+  } catch {
+    return typeof __dirname !== "undefined" ? __dirname : process.cwd();
+  }
+}
+function getClientDir2() {
+  if (clientDir2) return clientDir2;
+  const currentDir = getCurrentDir2();
+  clientDir2 = path.join(currentDir, "..", "dist", "client");
+  return clientDir2;
+}
+function getIndexHtml2() {
+  if (cachedIndexHtml2) return cachedIndexHtml2;
+  const indexPath = path.join(getClientDir2(), "index.html");
+  if (fs.existsSync(indexPath)) {
+    cachedIndexHtml2 = fs.readFileSync(indexPath, "utf-8");
+  } else {
+    cachedIndexHtml2 = `<!DOCTYPE html>
+<html lang="en">
+<head><meta charset="UTF-8"><title>Dashboard</title></head>
+<body>
+<div id="root">
+  <p style="font-family:sans-serif;text-align:center;margin-top:4rem">
+    Dashboard client not built. Run <code>vite build</code> first.
+  </p>
+</div>
+</body>
+</html>`;
+  }
+  return cachedIndexHtml2;
+}
+function serveStaticWeb(pathname) {
+  const dir = getClientDir2();
+  if (pathname !== "/" && pathname !== "/index.html") {
+    const filePath = path.join(dir, pathname);
+    if (fs.existsSync(filePath)) {
+      try {
+        const content = fs.readFileSync(filePath);
+        const ext = path.extname(pathname);
+        const mimeType = MIME_TYPES2[ext] ?? "application/octet-stream";
+        return new Response(content, {
+          status: 200,
+          headers: {
+            "Content-Type": mimeType,
+            "Content-Length": String(content.length),
+            "Cache-Control": pathname.includes("/assets/") ? "public, max-age=31536000, immutable" : "no-cache"
+          }
+        });
+      } catch {
+      }
+    }
+  }
+  const html = getIndexHtml2();
+  return new Response(html, {
+    status: 200,
+    headers: {
+      "Content-Type": "text/html",
+      "Cache-Control": "no-cache"
+    }
+  });
+}
+var CLIENT_ROUTE_REGEX2 = /^\/api\/clients\/([a-zA-Z0-9_-]+)(\/.*)?$/;
+function clientStoreInfo2(client) {
+  return {
+    cache: client.cache ? { type: client.cache.type, capabilities: client.cache.capabilities } : null,
+    dedup: client.dedup ? { type: client.dedup.type, capabilities: client.dedup.capabilities } : null,
+    rateLimit: client.rateLimit ? {
+      type: client.rateLimit.type,
+      capabilities: client.rateLimit.capabilities
+    } : null
+  };
+}
+async function routeApi(request, pathname, query, ctx) {
+  const method = request.method.toUpperCase();
+  if (pathname === "/api/health" && method === "GET") {
+    const clients = {};
+    for (const [name, client] of ctx.clients) {
+      clients[name] = clientStoreInfo2(client);
+    }
+    return jsonResponse({
+      status: "ok",
+      clients,
+      pollIntervalMs: ctx.pollIntervalMs
+    });
+  }
+  if (pathname === "/api/clients" && method === "GET") {
+    const clientList = [];
+    for (const [name, client] of ctx.clients) {
+      clientList.push({ name, stores: clientStoreInfo2(client) });
+    }
+    return jsonResponse({ clients: clientList });
+  }
+  const clientMatch = pathname.match(CLIENT_ROUTE_REGEX2);
+  if (clientMatch) {
+    const clientName = clientMatch[1];
+    const subPath = clientMatch[2] ?? "";
+    const client = ctx.clients.get(clientName);
+    if (!client) {
+      return errorResponse(`Unknown client: ${clientName}`, 404);
+    }
+    return routeClientApi2(request, subPath, method, client, query);
+  }
+  if (pathname.startsWith("/api/")) {
+    return errorResponse("Not found", 404);
+  }
+  return null;
+}
+async function routeClientApi2(request, subPath, method, client, query) {
+  if (subPath.startsWith("/cache")) {
+    if (!client.cache) return errorResponse("Cache store not configured", 404);
+    return routeCache(subPath, method, client.cache, query);
+  }
+  if (subPath.startsWith("/dedup")) {
+    if (!client.dedup) return errorResponse("Dedup store not configured", 404);
+    return routeDedup(subPath, method, client.dedup, query);
+  }
+  if (subPath.startsWith("/rate-limit")) {
+    if (!client.rateLimit)
+      return errorResponse("Rate limit store not configured", 404);
+    return routeRateLimit(request, subPath, method, client.rateLimit);
+  }
+  return errorResponse("Not found", 404);
+}
+async function routeCache(pathname, method, adapter, query) {
+  try {
+    if (pathname === "/cache/stats" && method === "GET") {
+      const stats = await adapter.getStats();
+      return jsonResponse({ stats, capabilities: adapter.capabilities });
+    }
+    if (pathname === "/cache/entries" && method === "GET") {
+      const page = parseInt(query.get("page") ?? "0", 10);
+      const limit = parseInt(query.get("limit") ?? "50", 10);
+      return jsonResponse(await adapter.listEntries(page, limit));
+    }
+    if (pathname === "/cache/entries" && method === "DELETE") {
+      await adapter.clearAll();
+      return jsonResponse({ cleared: true });
+    }
+    const isSingleEntry = pathname.startsWith("/cache/entries/") && pathname.split("/").length === 4;
+    if (isSingleEntry && method === "GET") {
+      const hash = extractParam(pathname, "/cache/entries/:hash");
+      if (!hash) return errorResponse("Not found", 404);
+      const entry = await adapter.getEntry(hash);
+      if (entry === void 0) return errorResponse("Not found", 404);
+      return jsonResponse({ hash, value: entry });
+    }
+    if (isSingleEntry && method === "DELETE") {
+      const hash = extractParam(pathname, "/cache/entries/:hash");
+      if (!hash) return errorResponse("Not found", 404);
+      await adapter.deleteEntry(hash);
+      return jsonResponse({ deleted: true });
+    }
+    if (isSingleEntry) {
+      return errorResponse("Method not allowed", 405);
+    }
+  } catch (err) {
+    return errorResponse(err instanceof Error ? err.message : "Unknown error");
+  }
+  return errorResponse("Not found", 404);
+}
+async function routeDedup(pathname, method, adapter, query) {
+  try {
+    if (pathname === "/dedup/stats" && method === "GET") {
+      const stats = await adapter.getStats();
+      return jsonResponse({ stats, capabilities: adapter.capabilities });
+    }
+    if (pathname === "/dedup/jobs" && method === "GET") {
+      const page = parseInt(query.get("page") ?? "0", 10);
+      const limit = parseInt(query.get("limit") ?? "50", 10);
+      return jsonResponse(await adapter.listJobs(page, limit));
+    }
+    const isSingleJob = pathname.startsWith("/dedup/jobs/") && pathname.split("/").length === 4;
+    if (isSingleJob && method === "GET") {
+      const hash = extractParam(pathname, "/dedup/jobs/:hash");
+      if (!hash) return errorResponse("Not found", 404);
+      const job = await adapter.getJob(hash);
+      if (!job) return errorResponse("Not found", 404);
+      return jsonResponse(job);
+    }
+    if (isSingleJob) {
+      return errorResponse("Method not allowed", 405);
+    }
+  } catch (err) {
+    return errorResponse(err instanceof Error ? err.message : "Unknown error");
+  }
+  return errorResponse("Not found", 404);
+}
+async function routeRateLimit(request, pathname, method, adapter) {
+  try {
+    if (pathname === "/rate-limit/stats" && method === "GET") {
+      const stats = await adapter.getStats();
+      return jsonResponse({ stats, capabilities: adapter.capabilities });
+    }
+    if (pathname === "/rate-limit/resources" && method === "GET") {
+      const resources = await adapter.listResources();
+      return jsonResponse({ resources });
+    }
+    if (pathname.endsWith("/config") && method === "PUT") {
+      const name = extractParam(pathname, "/rate-limit/resources/:name/config");
+      if (!name) return errorResponse("Not found", 404);
+      const body = await request.json();
+      await adapter.updateResourceConfig(name, body);
+      return jsonResponse({ updated: true });
+    }
+    if (pathname.endsWith("/reset") && method === "POST") {
+      const name = extractParam(pathname, "/rate-limit/resources/:name/reset");
+      if (!name) return errorResponse("Not found", 404);
+      await adapter.resetResource(name);
+      return jsonResponse({ reset: true });
+    }
+    const isSingleResource = pathname.startsWith("/rate-limit/resources/") && pathname.split("/").length === 4;
+    if (isSingleResource && method === "GET") {
+      const name = extractParam(pathname, "/rate-limit/resources/:name");
+      if (!name) return errorResponse("Not found", 404);
+      const status = await adapter.getResourceStatus(name);
+      return jsonResponse({ resource: name, ...status });
+    }
+    if (isSingleResource) {
+      return errorResponse("Method not allowed", 405);
+    }
+  } catch (err) {
+    return errorResponse(err instanceof Error ? err.message : "Unknown error");
+  }
+  return errorResponse("Not found", 404);
+}
+function createDashboardHandler(options) {
+  const opts = validateDashboardOptions(options);
+  const clients = /* @__PURE__ */ new Map();
+  for (const clientConfig of opts.clients) {
+    clients.set(clientConfig.name, {
+      name: clientConfig.name,
+      cache: clientConfig.cacheStore ? detectCacheAdapter(clientConfig.cacheStore) : void 0,
+      dedup: clientConfig.dedupeStore ? detectDedupeAdapter(clientConfig.dedupeStore) : void 0,
+      rateLimit: clientConfig.rateLimitStore ? detectRateLimitAdapter(clientConfig.rateLimitStore) : void 0
+    });
+  }
+  const ctx = {
+    clients,
+    pollIntervalMs: opts.pollIntervalMs
+  };
+  return async (request) => {
+    try {
+      const url = new URL(request.url);
+      let pathname = url.pathname;
+      if (opts.basePath !== "/" && pathname.startsWith(opts.basePath)) {
+        pathname = pathname.slice(opts.basePath.length) || "/";
+      }
+      const apiResponse = await routeApi(
+        request,
+        pathname,
+        url.searchParams,
+        ctx
+      );
+      if (apiResponse) return apiResponse;
+      return serveStaticWeb(pathname);
+    } catch {
+      return errorResponse("Internal server error", 500);
+    }
+  };
+}
+async function startDashboard(options) {
+  const opts = validateStandaloneOptions(options);
+  const middleware = createDashboard(options);
+  const server = http.createServer((req, res) => {
+    middleware(req, res);
+  });
+  return new Promise((resolve, reject) => {
+    server.on("error", reject);
+    server.listen(opts.port, opts.host, () => {
+      const addr = server.address();
+      const url = typeof addr === "string" ? addr : `http://${opts.host}:${opts.port}`;
+      console.log(`Dashboard running at ${url}`);
+      resolve({
+        server,
+        async close() {
+          return new Promise((res, rej) => {
+            server.close((err) => {
+              if (err) rej(err);
+              else res();
+            });
+          });
+        }
+      });
+    });
+  });
+}
+
+exports.createDashboard = createDashboard;
+exports.createDashboardHandler = createDashboardHandler;
+exports.startDashboard = startDashboard;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map