hillclimb 0.9.13 → 0.9.14

package/dist/git-diagnostics-worker.js

@@ -0,0 +1,205 @@
+// src/git-traces/git-diagnostics-worker.ts
+import { execFile } from "child_process";
+import net from "net";
+import path2 from "path";
+import { parentPort, workerData } from "worker_threads";
+
+// src/git-traces/git-diagnostics.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { Worker } from "worker_threads";
+var SAMPLE = {
+  stop: 0,
+  count: 1,
+  cpuMs: 2,
+  elapsedMs: 3,
+  bytes: 4,
+  growthMs: 5
+};
+var TRACE = { ready: 0, length: 1, partial: 2, done: 3 };
+function bundleBytes(file) {
+  let bytes = 0;
+  if (!file) return bytes;
+  for (const candidate of [file, `${file}.lock`]) {
+    try {
+      bytes = Math.max(bytes, fs.statSync(candidate).size);
+    } catch {
+    }
+  }
+  return bytes;
+}
+function parseCpuTime(value) {
+  const m = /^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+(?:\.\d+)?)$/.exec(value);
+  return m ? Math.round(
+    (Number(m[1] ?? 0) * 86400 + Number(m[2] ?? 0) * 3600 + Number(m[3]) * 60 + Number(m[4])) * 1e3
+  ) : null;
+}
+
+// src/git-traces/git-diagnostics-worker.ts
+var { parentPid, bundleFile, started } = workerData;
+var samples = new BigInt64Array(workerData.samples);
+var control = new Int32Array(workerData.control);
+var trace = Buffer.from(workerData.trace);
+var sockets = /* @__PURE__ */ new Set();
+var server;
+var full = false;
+var probe;
+function ready(value) {
+  Atomics.store(control, TRACE.ready, value);
+  Atomics.notify(control, TRACE.ready);
+}
+if (workerData.socketPath) {
+  server = net.createServer((socket) => {
+    socket.on("error", () => {
+    });
+    if (sockets.size >= 16) {
+      Atomics.store(control, TRACE.partial, 1);
+      socket.destroy();
+      return;
+    }
+    sockets.add(socket);
+    let pending = Buffer.alloc(0);
+    let dropping = false;
+    socket.on("data", (chunk) => {
+      let offset = 0;
+      while (offset < chunk.length) {
+        const length = Atomics.load(control, TRACE.length);
+        if (full || length === trace.length) {
+          Atomics.store(control, TRACE.partial, 1);
+          return;
+        }
+        const newline = chunk.indexOf(10, offset);
+        const end = newline < 0 ? chunk.length : newline + 1;
+        const piece = chunk.subarray(offset, end);
+        if (!dropping && pending.length + piece.length > 16384) {
+          dropping = true;
+          pending = Buffer.alloc(0);
+          Atomics.store(control, TRACE.partial, 1);
+        }
+        if (!dropping) {
+          if (newline < 0) pending = Buffer.concat([pending, piece]);
+          else {
+            const record = pending.length ? Buffer.concat([pending, piece]) : piece;
+            if (length + record.length <= trace.length) {
+              record.copy(trace, length);
+              Atomics.store(control, TRACE.length, length + record.length);
+            } else {
+              Atomics.store(control, TRACE.partial, 1);
+              full = true;
+            }
+            pending = Buffer.alloc(0);
+          }
+        }
+        if (newline >= 0) dropping = false;
+        offset = end;
+      }
+    });
+    socket.on("close", () => {
+      if (pending.length || dropping) Atomics.store(control, TRACE.partial, 1);
+      sockets.delete(socket);
+    });
+  });
+  server.on("error", () => ready(-1));
+  server.listen(workerData.socketPath, () => ready(1));
+} else ready(-1);
+parentPort?.once("message", async () => {
+  const stopped = new Promise((resolve) => {
+    if (!probe) resolve();
+    else {
+      probe.once("close", () => resolve());
+      probe.kill("SIGKILL");
+    }
+  });
+  const drained = new Promise((resolve) => {
+    if (!server?.listening) resolve();
+    else {
+      server.close(() => resolve());
+      setTimeout(() => {
+        if (sockets.size) Atomics.store(control, TRACE.partial, 1);
+        for (const socket of sockets) socket.destroy();
+        resolve();
+      }, 50).unref();
+    }
+  });
+  await Promise.all([stopped, drained]);
+  Atomics.store(control, TRACE.done, 1);
+  Atomics.notify(control, TRACE.done);
+});
+var cpuByPid = /* @__PURE__ */ new Map();
+var gitPid;
+var ambiguous = false;
+async function sample() {
+  if (Atomics.load(samples, SAMPLE.stop)) return;
+  const elapsed = Date.now() - started;
+  const bytes = bundleBytes(bundleFile);
+  if (bytes > Number(Atomics.load(samples, SAMPLE.bytes))) {
+    Atomics.store(samples, SAMPLE.bytes, BigInt(bytes));
+    Atomics.store(samples, SAMPLE.growthMs, BigInt(elapsed));
+  }
+  if (process.platform !== "win32") {
+    try {
+      const output = await new Promise((resolve, reject) => {
+        probe = execFile(
+          "ps",
+          ["-axo", "pid=,ppid=,time=,comm="],
+          {
+            encoding: "utf8",
+            timeout: 1e3,
+            maxBuffer: 8 * 1024 * 1024,
+            env: { ...process.env, LC_ALL: "C" }
+          },
+          (error, stdout) => {
+            probe = void 0;
+            if (error) reject(error);
+            else resolve(stdout);
+          }
+        );
+      });
+      if (Atomics.load(samples, SAMPLE.stop)) return;
+      const rows = output.split("\n").flatMap((line) => {
+        const m = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.+)$/.exec(line);
+        return m ? [
+          {
+            pid: Number(m[1]),
+            parent: Number(m[2]),
+            cpu: parseCpuTime(m[3]),
+            command: m[4]
+          }
+        ] : [];
+      });
+      const roots = rows.filter(
+        (r) => r.parent === parentPid && path2.basename(r.command) === "git"
+      ).map((r) => r.pid);
+      if (roots.length > 1 || roots.length === 1 && gitPid !== void 0 && roots[0] !== gitPid)
+        ambiguous = true;
+      if (roots.length === 1) gitPid ??= roots[0];
+      if (ambiguous) {
+        Atomics.store(samples, SAMPLE.cpuMs, -1n);
+        Atomics.store(samples, SAMPLE.count, 0n);
+        Atomics.store(samples, SAMPLE.elapsedMs, 0n);
+      }
+      const pids = new Set(ambiguous ? [] : roots);
+      for (let before = -1; before !== pids.size; ) {
+        before = pids.size;
+        for (const row of rows) if (pids.has(row.parent)) pids.add(row.pid);
+      }
+      for (const row of rows) {
+        if (pids.has(row.pid) && row.cpu !== null && (cpuByPid.has(row.pid) || cpuByPid.size < 4096))
+          cpuByPid.set(row.pid, Math.max(cpuByPid.get(row.pid) ?? 0, row.cpu));
+      }
+      if (pids.size && cpuByPid.size < 4096) {
+        Atomics.store(
+          samples,
+          SAMPLE.cpuMs,
+          BigInt([...cpuByPid.values()].reduce((a, b) => a + b, 0))
+        );
+        Atomics.add(samples, SAMPLE.count, 1n);
+        Atomics.store(samples, SAMPLE.elapsedMs, BigInt(elapsed));
+      }
+    } catch {
+    }
+  }
+  if (!Atomics.load(samples, SAMPLE.stop)) setTimeout(sample, 1e3);
+}
+setTimeout(sample, Math.max(0, 1e3 - (Date.now() - started)));