@h-rig/server 0.0.6-alpha.0

package/dist/src/server-helpers/http-utils.js

@@ -0,0 +1,135 @@
+// @bun
+// packages/server/src/server-helpers/http-utils.ts
+async function readJsonBody(req) {
+  const body = await req.text();
+  if (!body.trim()) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(body);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    throw new Error("Invalid JSON body");
+  }
+}
+function jsonResponse(payload, status = 200) {
+  return Response.json(payload, { status });
+}
+function normalizePositiveIntQuery(value, fallback) {
+  if (!value) {
+    return fallback;
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return fallback;
+  }
+  return parsed;
+}
+function isTruthyQuery(value) {
+  if (!value) {
+    return false;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+function formatSseEvent(event, data) {
+  return `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+}
+function notFound() {
+  return jsonResponse({ ok: false, error: "Not found" }, 404);
+}
+function badRequest(message) {
+  return jsonResponse({ ok: false, error: message }, 400);
+}
+function htmlResponse(html, status = 200) {
+  return new Response(html, {
+    status,
+    headers: {
+      "Content-Type": "text/html;charset=utf-8"
+    }
+  });
+}
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+function isAuthorizedHttpRequest(req, authToken) {
+  if (!authToken)
+    return true;
+  const header = req.headers.get("authorization");
+  if (!header)
+    return false;
+  const match = header.match(/^Bearer\s+(.+)$/i);
+  return Boolean(match && match[1] === authToken);
+}
+function resolveAllowedBrowserOrigin(req) {
+  const originHeader = req.headers.get("origin");
+  if (!originHeader)
+    return null;
+  try {
+    const requestUrl = new URL(req.url);
+    const originUrl = new URL(originHeader);
+    if (!["http:", "https:"].includes(originUrl.protocol)) {
+      return null;
+    }
+    const sameHost = originUrl.hostname === requestUrl.hostname;
+    const equivalentLoopback = ["127.0.0.1", "localhost"].includes(originUrl.hostname) && ["127.0.0.1", "localhost"].includes(requestUrl.hostname);
+    if (!sameHost && !equivalentLoopback) {
+      return null;
+    }
+    return originUrl.origin;
+  } catch {
+    return null;
+  }
+}
+function buildCorsHeaders(req, origin) {
+  const headers = new Headers;
+  headers.set("Access-Control-Allow-Origin", origin);
+  headers.set("Vary", "Origin");
+  headers.set("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  headers.set("Access-Control-Allow-Headers", req.headers.get("access-control-request-headers") ?? "Authorization, Content-Type");
+  headers.set("Access-Control-Max-Age", "600");
+  if (req.headers.get("access-control-request-private-network") === "true") {
+    headers.set("Access-Control-Allow-Private-Network", "true");
+  }
+  return headers;
+}
+function withCorsHeaders(response, req, origin) {
+  if (!origin)
+    return response;
+  const headers = new Headers(response.headers);
+  const corsHeaders = buildCorsHeaders(req, origin);
+  for (const [key, value] of corsHeaders.entries()) {
+    headers.set(key, value);
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function isAuthorizedLinearWebhookRequest(req) {
+  const secret = process.env.LINEAR_WEBHOOK_SECRET?.trim();
+  if (!secret) {
+    return false;
+  }
+  return req.headers.get("x-linear-webhook-secret") === secret;
+}
+export {
+  withCorsHeaders,
+  resolveAllowedBrowserOrigin,
+  readJsonBody,
+  notFound,
+  normalizePositiveIntQuery,
+  jsonResponse,
+  isTruthyQuery,
+  isAuthorizedLinearWebhookRequest,
+  isAuthorizedHttpRequest,
+  htmlResponse,
+  formatSseEvent,
+  escapeHtml,
+  buildCorsHeaders,
+  badRequest
+};

package/dist/src/server-helpers/inspector-agent-lifecycle.js

@@ -0,0 +1,104 @@
+// @bun
+// packages/server/src/server-helpers/inspector-agent-lifecycle.ts
+function createInspectorAgentLifecycleController(options) {
+  const initialDelayMs = Math.max(1, options.initialDelayMs ?? 5000);
+  const maxDelayMs = Math.max(initialDelayMs, options.maxDelayMs ?? 5 * 60000);
+  const backoffFactor = Math.max(1, options.backoffFactor ?? 2);
+  const now = options.now ?? Date.now;
+  const setTimer = options.setTimer ?? ((callback, delayMs) => setTimeout(callback, delayMs));
+  const clearTimer = options.clearTimer ?? clearTimeout;
+  const logError = options.logError ?? ((error, retryDelayMs2) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[server] inspector agent start failed: ${message} (next retry in ${Math.round(retryDelayMs2 / 1000)}s)`);
+  });
+  let retryDelayMs = initialDelayMs;
+  let nextAttemptAt = now();
+  let timer = null;
+  let stopped = false;
+  let lastError = null;
+  let lastLoggedError = null;
+  let failureCount = 0;
+  const snapshot = () => ({
+    disabled: options.disabled,
+    retryDelayMs: options.disabled || !options.agent ? null : retryDelayMs,
+    nextAttemptAt: options.disabled || !options.agent ? null : new Date(nextAttemptAt).toISOString(),
+    lastError,
+    failureCount
+  });
+  const scheduleNext = () => {
+    if (stopped || options.disabled || !options.agent || timer !== null)
+      return;
+    const delay = Math.max(0, nextAttemptAt - now());
+    timer = setTimer(() => {
+      timer = null;
+      attemptNow();
+    }, delay);
+  };
+  const resetHealthyBackoff = () => {
+    lastLoggedError = null;
+    lastError = null;
+    retryDelayMs = initialDelayMs;
+    failureCount = 0;
+  };
+  const attemptNow = async () => {
+    if (stopped || options.disabled || !options.agent)
+      return;
+    const status = options.agent.snapshot().status;
+    if (status === "starting" || status === "idle" || status === "running") {
+      resetHealthyBackoff();
+      nextAttemptAt = now() + retryDelayMs;
+      scheduleNext();
+      return;
+    }
+    try {
+      await options.agent.start();
+      resetHealthyBackoff();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      lastError = message;
+      failureCount += 1;
+      retryDelayMs = Math.min(Math.round(retryDelayMs * backoffFactor), maxDelayMs);
+      if (message !== lastLoggedError) {
+        lastLoggedError = message;
+        logError(error, retryDelayMs);
+      }
+    }
+    nextAttemptAt = now() + retryDelayMs;
+    scheduleNext();
+  };
+  return {
+    start() {
+      if (!options.disabled) {
+        attemptNow();
+      }
+    },
+    attemptNow,
+    stop() {
+      stopped = true;
+      if (timer !== null) {
+        clearTimer(timer);
+        timer = null;
+      }
+      options.agent?.stop();
+    },
+    snapshot
+  };
+}
+function inspectorAgentLifecycleSnapshot(input) {
+  const agentSnapshot = input.agent?.snapshot() ?? null;
+  return {
+    service: {
+      available: input.inspector !== null,
+      running: input.inspector?.isRunning() ?? false
+    },
+    agent: {
+      available: input.agent !== null,
+      status: input.retry?.disabled ? "disabled" : agentSnapshot?.status ?? "unavailable",
+      retry: input.retry
+    }
+  };
+}
+export {
+  inspectorAgentLifecycleSnapshot,
+  createInspectorAgentLifecycleController
+};