@ulpi/cli 0.1.4 → 0.1.6

package/dist/chunk-Z53CAR7G.js

@@ -0,0 +1,298 @@
+// ../../packages/http/dist/middleware/auth.js
+import { randomBytes } from "crypto";
+var apiSecret;
+function generateApiSecret() {
+  return randomBytes(32).toString("hex");
+}
+function setApiSecret(secret) {
+  apiSecret = secret;
+}
+function getApiSecret() {
+  return apiSecret;
+}
+var LOOPBACK_ADDRESSES = /* @__PURE__ */ new Set(["127.0.0.1", "::1", "::ffff:127.0.0.1"]);
+function validateLoopback(req) {
+  const remoteAddr = req.socket.remoteAddress ?? "";
+  return LOOPBACK_ADDRESSES.has(remoteAddr);
+}
+function validateAuth(req) {
+  if (!validateLoopback(req))
+    return false;
+  if (apiSecret) {
+    const headerSecret = req.headers["x-ulpi-secret"];
+    if (headerSecret === apiSecret)
+      return true;
+    try {
+      const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+      const paramSecret = url.searchParams.get("secret");
+      if (paramSecret === apiSecret)
+        return true;
+    } catch {
+    }
+    return false;
+  }
+  return true;
+}
+
+// ../../packages/http/dist/router.js
+function createRouter() {
+  const routes = [];
+  function add(method, pattern, handler) {
+    routes.push({ method, pattern, handler });
+  }
+  return {
+    get(pattern, handler) {
+      add("GET", pattern, handler);
+    },
+    post(pattern, handler) {
+      add("POST", pattern, handler);
+    },
+    put(pattern, handler) {
+      add("PUT", pattern, handler);
+    },
+    patch(pattern, handler) {
+      add("PATCH", pattern, handler);
+    },
+    delete(pattern, handler) {
+      add("DELETE", pattern, handler);
+    },
+    /**
+     * Try each registered route in order. For string patterns, performs an
+     * exact match against `ctx.pathname`. For RegExp patterns, tests the
+     * pathname and extracts named groups (or positional captures indexed by
+     * their number) into `params`.
+     *
+     * Returns `true` if a matching route was found (and its handler was
+     * invoked), `false` otherwise.
+     */
+    async handle(ctx) {
+      for (const route of routes) {
+        if (route.method !== ctx.method)
+          continue;
+        let params = {};
+        if (typeof route.pattern === "string") {
+          if (ctx.pathname !== route.pattern)
+            continue;
+        } else {
+          const match = route.pattern.exec(ctx.pathname);
+          if (!match)
+            continue;
+          if (match.groups) {
+            params = { ...match.groups };
+          }
+          for (let i = 1; i < match.length; i++) {
+            if (match[i] !== void 0) {
+              params[String(i)] = decodeURIComponent(match[i]);
+            }
+          }
+        }
+        await route.handler({ ...ctx, params });
+        return true;
+      }
+      return false;
+    }
+  };
+}
+
+// ../../packages/http/dist/request.js
+function readBody(req, maxSize = 1048576) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > maxSize) {
+        req.destroy();
+        reject(new Error("Request body too large"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
+function readBodyRaw(req, maxSize = 5 * 1024 * 1024) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > maxSize) {
+        req.destroy();
+        reject(new Error("Request body too large"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+async function parseJsonBody(req) {
+  try {
+    const raw = await readBody(req);
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return { data: null, error: "Expected a JSON object" };
+    }
+    return { data: parsed, error: null };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Invalid JSON body";
+    return { data: null, error: message };
+  }
+}
+function parseMultipartImage(body, boundary) {
+  const boundaryBuffer = Buffer.from(`--${boundary}`);
+  const start = body.indexOf(boundaryBuffer);
+  if (start === -1)
+    return null;
+  const headerEnd = body.indexOf(Buffer.from("\r\n\r\n"), start);
+  if (headerEnd === -1)
+    return null;
+  const headers = body.subarray(start + boundaryBuffer.length + 2, headerEnd).toString();
+  const ctMatch = headers.match(/Content-Type:\s*(.+)/i);
+  const contentType = ctMatch ? ctMatch[1].trim() : "image/png";
+  const dataStart = headerEnd + 4;
+  const nextBoundary = body.indexOf(boundaryBuffer, dataStart);
+  const dataEnd = nextBoundary !== -1 ? nextBoundary - 2 : body.length;
+  return { data: body.subarray(dataStart, dataEnd), contentType };
+}
+
+// ../../packages/http/dist/response.js
+function resolveOrigin(options, req) {
+  if (!options)
+    return "*";
+  if (typeof options.origin === "function")
+    return options.origin(req);
+  return options.origin;
+}
+function corsHeaders(options, req) {
+  const headers = {
+    "Access-Control-Allow-Origin": resolveOrigin(options, req),
+    "Access-Control-Allow-Methods": options?.methods ?? "GET, POST, PUT, PATCH, DELETE, OPTIONS",
+    "Access-Control-Allow-Headers": options?.headers ?? "Content-Type, Authorization"
+  };
+  if (options?.credentials) {
+    headers["Access-Control-Allow-Credentials"] = "true";
+  }
+  if (options?.maxAge) {
+    headers["Access-Control-Max-Age"] = String(options.maxAge);
+  }
+  return headers;
+}
+function jsonResponse(res, data, status = 200, req, cors) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    ...corsHeaders(cors, req)
+  });
+  res.end(body);
+}
+function notFound(res, message = "Not found", req, cors) {
+  jsonResponse(res, { error: message }, 404, req, cors);
+}
+function sseHeaders(res, req, cors) {
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+    ...corsHeaders(cors, req)
+  });
+}
+function sseEvent(res, eventName, data) {
+  res.write(`event: ${eventName}
+data: ${JSON.stringify(data)}
+
+`);
+}
+
+// ../../packages/http/dist/middleware/rate-limit.js
+var store = /* @__PURE__ */ new Map();
+var CLEANUP_INTERVAL = 6e4;
+setInterval(() => {
+  const now = Date.now();
+  for (const [key, entry] of store) {
+    if (now >= entry.resetAt) {
+      store.delete(key);
+    }
+  }
+}, CLEANUP_INTERVAL).unref();
+function checkRateLimit(key, limit = 200, windowMs = 6e4) {
+  const now = Date.now();
+  const entry = store.get(key);
+  if (!entry || now >= entry.resetAt) {
+    store.set(key, { count: 1, resetAt: now + windowMs });
+    return true;
+  }
+  entry.count++;
+  return entry.count <= limit;
+}
+
+// ../../packages/http/dist/middleware/cors.js
+function handleCorsPreFlight(req, res, options) {
+  if ((req.method ?? "GET") !== "OPTIONS")
+    return false;
+  res.writeHead(204, corsHeaders(options, req));
+  res.end();
+  return true;
+}
+
+// ../../packages/http/dist/websocket.js
+import { WebSocketServer } from "ws";
+
+// ../../packages/http/dist/sse.js
+var SSEBroadcaster = class _SSEBroadcaster {
+  static MAX_CLIENTS = 100;
+  clients = /* @__PURE__ */ new Set();
+  /** Check if the broadcaster can accept another client. */
+  canAccept() {
+    return this.clients.size < _SSEBroadcaster.MAX_CLIENTS;
+  }
+  /** Register a new SSE client. */
+  add(res) {
+    this.clients.add(res);
+  }
+  /** Remove a disconnected SSE client. */
+  remove(res) {
+    this.clients.delete(res);
+  }
+  /** Broadcast a named SSE event to every connected client. */
+  broadcast(eventName, data) {
+    const message = `event: ${eventName}
+data: ${JSON.stringify(data)}
+
+`;
+    for (const client of this.clients) {
+      try {
+        client.write(message);
+      } catch {
+        this.clients.delete(client);
+      }
+    }
+  }
+  /** Number of currently connected clients. */
+  get size() {
+    return this.clients.size;
+  }
+};
+
+export {
+  createRouter,
+  readBody,
+  readBodyRaw,
+  parseJsonBody,
+  parseMultipartImage,
+  jsonResponse,
+  notFound,
+  sseHeaders,
+  sseEvent,
+  generateApiSecret,
+  setApiSecret,
+  getApiSecret,
+  validateLoopback,
+  validateAuth,
+  checkRateLimit,
+  handleCorsPreFlight,
+  SSEBroadcaster
+};