@holdpoint/live-daemon 0.1.0-alpha.4 → 0.1.0-alpha.6

package/dist/index.js

@@ -133,7 +133,7 @@ async function readHealthyDaemonLock(homeDir) {
 // src/server.ts
 import { createServer as createServer2 } from "http";
 import { randomUUID as randomUUID2 } from "crypto";
-import { createReadStream, existsSync as existsSync4 } from "fs";
+import { createReadStream, existsSync as existsSync4, renameSync, writeFileSync as writeFileSync2 } from "fs";
 import { dirname, extname, join as join3, resolve as resolve3, sep } from "path";
 import { fileURLToPath, URL } from "url";
 import {
@@ -142,6 +142,7 @@ import {
   EventV1Schema as EventV1Schema2,
   EventsBatchSchema
 } from "@holdpoint/live-protocol";
+import { parseHoldpointYaml } from "@holdpoint/yaml-core";
 import { WebSocket, WebSocketServer } from "ws";
 
 // src/auth.ts
@@ -181,6 +182,17 @@ async function readJsonBody(req) {
   if (chunks.length === 0) return null;
   return JSON.parse(Buffer.concat(chunks).toString("utf8"));
 }
+async function readTextBody(req, maxBytes = 512e3) {
+  const chunks = [];
+  let total = 0;
+  for await (const chunk of req) {
+    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+    total += buf.length;
+    if (total > maxBytes) throw new Error("Request body too large");
+    chunks.push(buf);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
 function authorizeRequest(req, res, token, port) {
   const origin = req.headers.origin;
   if (origin && origin !== `http://127.0.0.1:${port}`) {
@@ -363,33 +375,37 @@ function sha12(value) {
   return createHash("sha256").update(value).digest("hex").slice(0, 12);
 }
 function identifyProject(cwd) {
+  let root;
   try {
-    const root = realpathSync2(
+    root = realpathSync2(
       execFileSync("git", ["rev-parse", "--show-toplevel"], {
         cwd,
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"]
       }).trim()
     );
-    return {
-      hash: sha12(root),
-      name: basename(root),
-      root
-    };
   } catch {
-    const root = realpathSync2(cwd);
-    return {
-      hash: sha12(root),
-      name: basename(root),
-      root
-    };
+    try {
+      root = realpathSync2(cwd);
+    } catch {
+      root = cwd;
+    }
   }
+  return {
+    hash: sha12(root),
+    name: basename(root) || root,
+    root
+  };
 }
 
 // src/store.ts
 function sessionFileName(engine, sessionId) {
   return `${encodeURIComponent(engine)}-${encodeURIComponent(sessionId)}.jsonl`;
 }
+function describeError(err) {
+  if (err instanceof Error) return err.message || err.name;
+  return String(err);
+}
 async function readJsonl(filePath) {
   const raw = await readFile(filePath, "utf8");
   return raw.split("\n").map((line) => line.trim()).filter(Boolean).flatMap((line) => {
@@ -421,14 +437,33 @@ var LiveStore = class _LiveStore {
   async replayPending() {
     const pendingDir = join2(this.homeDir, "spool", "pending");
     if (!existsSync3(pendingDir)) return;
-    const entries = await readdir(pendingDir);
+    let entries;
+    try {
+      entries = await readdir(pendingDir);
+    } catch (err) {
+      console.error(`[holdpoint] failed to read pending dir: ${describeError(err)}`);
+      return;
+    }
     for (const entry of entries.filter((name) => name.endsWith(".jsonl"))) {
       const filePath = join2(pendingDir, entry);
-      const events = await readJsonl(filePath);
-      if (events.length > 0) {
-        await this.ingestMany(events);
+      let events = [];
+      try {
+        events = await readJsonl(filePath);
+      } catch (err) {
+        console.error(`[holdpoint] failed to read pending file ${entry}: ${describeError(err)}`);
+      }
+      for (const event of events) {
+        try {
+          await this.ingest(event);
+        } catch (err) {
+          console.error(`[holdpoint] dropped pending event from ${entry}: ${describeError(err)}`);
+        }
+      }
+      try {
+        await rm(filePath, { force: true });
+      } catch (err) {
+        console.error(`[holdpoint] failed to remove pending file ${entry}: ${describeError(err)}`);
       }
-      await rm(filePath, { force: true });
     }
   }
   async ingestMany(events) {
@@ -680,7 +715,6 @@ function matchesSubscription(subscription, event) {
 // src/server.ts
 var __dirname = dirname(fileURLToPath(import.meta.url));
 var LIVE_UI_DIR = join3(__dirname, "live-ui");
-var BUILDER_UI_DIR = join3(__dirname, "builder-ui");
 var CONTENT_SECURITY_POLICY = "default-src 'self'; img-src 'self' data:; style-src 'self' 'unsafe-inline'; connect-src 'self' ws: http:; object-src 'none'; base-uri 'none'; frame-ancestors 'none'";
 var MIME = {
   ".css": "text/css; charset=utf-8",
@@ -768,10 +802,10 @@ function resolveUiFilePath(uiDir, requestedPath) {
   return existsSync4(join3(uiDir, "index.html")) ? join3(uiDir, "index.html") : null;
 }
 function normalizeUiPath(path) {
-  if (!path) return "/live/";
-  if (path === "/live" || path.startsWith("/live/")) return "/live/";
-  if (path === "/builder" || path.startsWith("/builder/")) return "/builder/";
-  return "/live/";
+  if (path === "/builder" || path?.startsWith("/builder/")) {
+    return { pathname: "/live/", tab: "checks" };
+  }
+  return { pathname: "/live/" };
 }
 function registerProjectFromAuthUrl(url, registeredProjects) {
   const hash = url.searchParams.get("project");
@@ -990,14 +1024,17 @@ async function startLiveServer(options) {
         return;
       }
       registerProjectFromAuthUrl(url, registered);
-      const redirectPath = normalizeUiPath(url.searchParams.get("path"));
+      const redirectTarget = normalizeUiPath(url.searchParams.get("path"));
       const redirectUrl = new URL(`http://${host}:${actualPort}`);
-      redirectUrl.pathname = redirectPath;
+      redirectUrl.pathname = redirectTarget.pathname;
       for (const [key, value] of url.searchParams.entries()) {
         if (key !== "token" && key !== "path") {
           redirectUrl.searchParams.set(key, value);
         }
       }
+      if (redirectTarget.tab) {
+        redirectUrl.searchParams.set("tab", redirectTarget.tab);
+      }
       writeUiAuthCookie(res, state.token);
       res.writeHead(302, {
         location: redirectUrl.toString(),
@@ -1048,6 +1085,47 @@ async function startLiveServer(options) {
       createReadStream(reportsPath).pipe(res);
       return;
     }
+    if (req.method === "PUT" && url.pathname === "/__holdpoint/checks") {
+      if (!authorizeRequest(req, res, state.token, actualPort)) {
+        return;
+      }
+      const project = getProjectForRequest(url, registered);
+      if (!project) {
+        writeJson(res, 404, { ok: false, error: "Project not registered for this UI session" });
+        return;
+      }
+      const checksPath = resolve3(project.root, "checks.yaml");
+      if (!isWithinRoot(checksPath, project.root)) {
+        writeJson(res, 400, { ok: false, error: "Invalid checks path" });
+        return;
+      }
+      let body;
+      try {
+        body = await readTextBody(req);
+      } catch {
+        writeJson(res, 413, { ok: false, error: "checks.yaml is too large" });
+        return;
+      }
+      try {
+        parseHoldpointYaml(body);
+      } catch (parseError) {
+        writeJson(res, 422, {
+          ok: false,
+          error: `Invalid checks.yaml: ${parseError.message}`
+        });
+        return;
+      }
+      try {
+        const tmpPath = `${checksPath}.holdpoint-tmp-${randomUUID2().slice(0, 8)}`;
+        writeFileSync2(tmpPath, body, "utf8");
+        renameSync(tmpPath, checksPath);
+      } catch (writeError) {
+        writeJson(res, 500, { ok: false, error: writeError.message });
+        return;
+      }
+      writeJson(res, 200, { ok: true });
+      return;
+    }
     if (url.pathname.startsWith("/v1/") && !authorizeRequest(req, res, state.token, actualPort)) {
       return;
     }
@@ -1142,28 +1220,30 @@ async function startLiveServer(options) {
         res.end();
         return;
       }
-      if (url.pathname === "/live" || url.pathname === "/builder") {
-        res.writeHead(302, { location: `${url.pathname}/`, "cache-control": "no-store" });
+      if (url.pathname === "/builder" || url.pathname.startsWith("/builder/")) {
+        const target = new URL("/live/", `http://${host}:${actualPort}`);
+        for (const [key, value] of url.searchParams.entries()) target.searchParams.set(key, value);
+        target.searchParams.set("tab", "checks");
+        res.writeHead(302, {
+          location: `${target.pathname}${target.search}`,
+          "cache-control": "no-store"
+        });
+        res.end();
+        return;
+      }
+      if (url.pathname === "/live") {
+        res.writeHead(302, { location: "/live/", "cache-control": "no-store" });
         res.end();
         return;
       }
-      const uiRoute = url.pathname.startsWith("/builder/") ? {
-        appName: "Holdpoint Builder",
-        dir: BUILDER_UI_DIR,
-        path: url.pathname.replace(/^\/builder\/?/, "")
-      } : url.pathname.startsWith("/live/") ? {
-        appName: "Holdpoint Live",
-        dir: LIVE_UI_DIR,
-        path: url.pathname.replace(/^\/live\/?/, "")
-      } : null;
-      if (!uiRoute) {
+      if (!url.pathname.startsWith("/live/")) {
         res.writeHead(302, { location: "/live/", "cache-control": "no-store" });
         res.end();
         return;
       }
-      const filePath = resolveUiFilePath(uiRoute.dir, uiRoute.path);
+      const filePath = resolveUiFilePath(LIVE_UI_DIR, url.pathname.replace(/^\/live\/?/, ""));
       if (!filePath) {
-        servePlaceholder(res, uiRoute.appName);
+        servePlaceholder(res, "Holdpoint Live");
         return;
       }
       serveUiAsset(res, filePath);