@xagents_in/unmask 0.0.0-stage → 0.1.0

package/dist/server/runner.mjs

@@ -0,0 +1,280 @@
+import { spawn } from "node:child_process";
+import { randomBytes, createHash } from "node:crypto";
+import { createServer, createConnection } from "node:net";
+import { constants } from "node:fs";
+import {
+  mkdir,
+  readdir,
+  lstat,
+  chmod,
+  realpath,
+  open,
+  rm,
+} from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { validateReport } from "../core/report.mjs";
+import { parsePackageSpec } from "../core/acquire.mjs";
+
+const JOB_NAME = /^job-[a-f0-9]{32}$/;
+const fail = (code) => new Error(code);
+function boundedReport(report, cap) {
+  validateReport(report);
+  if (Buffer.byteLength(JSON.stringify(report)) > cap)
+    throw fail("analysis-result-cap");
+  return report;
+}
+
+function leasePath(root, name) {
+  const rootHash = createHash("sha256").update(root).digest("hex").slice(0, 16);
+  return `/tmp/um-${process.getuid()}-${rootHash}-${name.slice(4)}.sock`;
+}
+async function jobLease(root, name) {
+  const filename = leasePath(root, name);
+  const server = createServer((socket) => socket.destroy());
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(filename, () => {
+      server.removeListener("error", reject);
+      resolve();
+    });
+  });
+  const close = () =>
+    new Promise((resolve, reject) =>
+      server.close((error) => (error ? reject(error) : resolve())),
+    );
+  try {
+    await chmod(filename, 0o600);
+    // Node 24 exposes the listening descriptor here; the worker must inherit it.
+    const fd = server._handle?.fd;
+    if (!Number.isInteger(fd) || fd < 0)
+      throw fail("analysis-lease-unavailable");
+    server.unref();
+    return { close, fd };
+  } catch (error) {
+    await close();
+    throw error;
+  }
+}
+async function abandonedLease(filename) {
+  try {
+    const stat = await lstat(filename);
+    if (!stat.isSocket() || stat.uid !== process.getuid()) return false;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+  return new Promise((resolve) => {
+    const socket = createConnection(filename);
+    let done = false;
+    const timer = setTimeout(() => finish(false), 500);
+    function finish(stale) {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      socket.destroy();
+      resolve(stale);
+    }
+    socket.once("connect", () => finish(false));
+    socket.on("error", (error) => finish(error.code === "ECONNREFUSED"));
+  });
+}
+
+async function readResult(workDir, cap) {
+  const handle = await open(
+    path.join(workDir, "report.json"),
+    constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK,
+  );
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile()) throw fail("analysis-worker-invalid-result");
+    if (stat.size > cap) throw fail("analysis-result-cap");
+    const bytes = Buffer.alloc(stat.size);
+    let offset = 0;
+    while (offset < bytes.length) {
+      const { bytesRead } = await handle.read(
+        bytes,
+        offset,
+        bytes.length - offset,
+        offset,
+      );
+      if (!bytesRead) throw fail("analysis-worker-invalid-result");
+      offset += bytesRead;
+    }
+    return boundedReport(
+      JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes)),
+      cap,
+    );
+  } finally {
+    await handle.close();
+  }
+}
+
+function runWorker(workerURL, request, signal, deadline, leaseFd) {
+  return new Promise((resolve, reject) => {
+    let stopped, timer, child;
+    const stop = (reason) => {
+      stopped ||= reason;
+      child?.kill("SIGKILL");
+    };
+    const abort = () => stop("analysis-aborted");
+    if (signal?.aborted) return reject(fail("analysis-aborted"));
+    try {
+      child = spawn(process.execPath, ["--max-old-space-size=512", workerURL], {
+        cwd: request.workDir,
+        env: { LANG: "C.UTF-8", TMPDIR: request.workDir },
+        stdio: ["pipe", "ignore", "ignore", leaseFd],
+      });
+    } catch {
+      return reject(fail("analysis-worker-failed"));
+    }
+    signal?.addEventListener("abort", abort, { once: true });
+    timer = setTimeout(() => stop("analysis-timeout"), deadline);
+    child.on("error", () => {
+      stopped ||= "analysis-worker-failed";
+    });
+    child.stdin.on("error", () => stop("analysis-worker-failed"));
+    child.once("close", (code) => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+      if (stopped || code !== 0)
+        reject(fail(stopped || "analysis-worker-failed"));
+      else resolve();
+    });
+    child.stdin.end(JSON.stringify(request));
+    if (signal?.aborted) abort();
+  });
+}
+
+async function explainReport(report, client, signal, cap) {
+  const controller = new AbortController();
+  let timer, abort;
+  const cancellation = new Promise((resolve, reject) => {
+    abort = () => {
+      controller.abort();
+      reject(fail("analysis-aborted"));
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+    timer = setTimeout(() => {
+      controller.abort();
+      resolve({ status: "timeout" });
+    }, 135000);
+  });
+  try {
+    if (signal?.aborted) throw fail("analysis-aborted");
+    const operation = Promise.resolve().then(() =>
+      client.explain(structuredClone(report), { signal: controller.signal }),
+    );
+    let model;
+    try {
+      model = await Promise.race([operation, cancellation]);
+      if (signal?.aborted) throw fail("analysis-aborted");
+      return boundedReport({ ...report, model }, cap);
+    } catch {
+      if (signal?.aborted) throw fail("analysis-aborted");
+      for (const model of [
+        { status: "unavailable", reason: "model-failed" },
+        { status: "unavailable" },
+        { status: "failed" },
+      ]) {
+        const fallback = { ...report, model };
+        if (Buffer.byteLength(JSON.stringify(fallback)) <= cap)
+          return boundedReport(fallback, cap);
+      }
+      throw fail("analysis-result-cap");
+    }
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", abort);
+  }
+}
+
+export async function createRunner({
+  tempRoot,
+  workerURL = new URL("./worker.mjs", import.meta.url),
+  deterministicMs = 120000,
+  maxResultBytes = 67108864,
+  modelClient,
+} = {}) {
+  if (typeof tempRoot !== "string" || !path.isAbsolute(tempRoot))
+    throw new TypeError("An absolute private tempRoot is required");
+  if (
+    !Number.isSafeInteger(deterministicMs) ||
+    deterministicMs < 1 ||
+    deterministicMs > 120000 ||
+    !Number.isSafeInteger(maxResultBytes) ||
+    maxResultBytes < 1 ||
+    maxResultBytes > 67108864
+  )
+    throw new TypeError("Invalid runner limits");
+  if (modelClient !== undefined && typeof modelClient.explain !== "function")
+    throw new TypeError("Invalid model client");
+  const filename =
+    workerURL instanceof URL ? fileURLToPath(workerURL) : workerURL;
+  if (typeof filename !== "string" || !path.isAbsolute(filename))
+    throw new TypeError("Worker must be an absolute trusted module path");
+  await mkdir(tempRoot, { recursive: true, mode: 0o700 });
+  const rootStat = await lstat(tempRoot);
+  if (
+    !rootStat.isDirectory() ||
+    rootStat.isSymbolicLink() ||
+    rootStat.uid !== process.getuid?.()
+  )
+    throw new TypeError("tempRoot must be a private directory");
+  await chmod(tempRoot, 0o700);
+  const privateRoot = await realpath(tempRoot);
+  for (const entry of await readdir(privateRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !JOB_NAME.test(entry.name)) continue;
+    const owner = leasePath(privateRoot, entry.name);
+    if (await abandonedLease(owner)) {
+      await rm(path.join(privateRoot, entry.name), {
+        recursive: true,
+        force: true,
+      });
+      await rm(owner, { force: true });
+    }
+  }
+  let active = false;
+  return async function runAnalysis(spec, { signal } = {}) {
+    parsePackageSpec(spec);
+    if (signal !== undefined && !(signal instanceof AbortSignal))
+      throw new TypeError("Invalid analysis signal");
+    if (active) throw fail("analysis-busy");
+    active = true;
+    let workDir, lease;
+    try {
+      if (signal?.aborted) throw fail("analysis-aborted");
+      const owned = path.join(
+        privateRoot,
+        `job-${randomBytes(16).toString("hex")}`,
+      );
+      lease = await jobLease(privateRoot, path.basename(owned));
+      await mkdir(owned, { mode: 0o700 });
+      workDir = owned;
+      if (signal?.aborted) throw fail("analysis-aborted");
+      await runWorker(
+        filename,
+        { spec, workDir, maxResultBytes },
+        signal,
+        deterministicMs,
+        lease.fd,
+      );
+      if (signal?.aborted) throw fail("analysis-aborted");
+      const report = await readResult(workDir, maxResultBytes);
+      if (signal?.aborted) throw fail("analysis-aborted");
+      return modelClient
+        ? await explainReport(report, modelClient, signal, maxResultBytes)
+        : report;
+    } finally {
+      try {
+        if (workDir) await rm(workDir, { recursive: true, force: true });
+      } finally {
+        try {
+          if (lease) await lease.close();
+        } finally {
+          active = false;
+        }
+      }
+    }
+  };
+}

package/dist/server/store.mjs

@@ -0,0 +1,105 @@
+const deterministicCaps = new Set([
+  "compressed-cap",
+  "expanded-cap",
+  "ratio-cap",
+  "entry-cap",
+  "path-cap",
+  "path-depth-cap",
+  "path-node-cap",
+  "metadata-cap",
+]);
+const transientModelStatuses = new Set([
+  "unavailable",
+  "timeout",
+  "failed",
+  "invalid",
+  "quota-exceeded",
+]);
+
+function reusable(record) {
+  if (!record.report || transientModelStatuses.has(record.report.model?.status))
+    return false;
+  if (record.status === "done") return record.report.policy?.exitCode !== 2;
+  return (
+    record.status === "incomplete" &&
+    record.report.policy?.exitCode === 2 &&
+    record.report.failures?.length > 0 &&
+    record.report.failures.every(
+      (failure) =>
+        deterministicCaps.has(failure.code) ||
+        (failure.code === "source-selection-unresolved" &&
+          failure.reason === "ambiguous-manifest"),
+    )
+  );
+}
+
+export function createReportStore({
+  maxEntries = 200,
+  maxBytes = 64 * 1024 * 1024,
+  ttlMs = 1800000,
+  clock = { now: Date.now },
+} = {}) {
+  for (const value of [maxEntries, maxBytes, ttlMs])
+    if (!Number.isSafeInteger(value) || value < 1)
+      throw new TypeError("Store limits must be positive integers");
+  const records = new Map();
+  let bytes = 0;
+  function remove(id) {
+    const record = records.get(id);
+    if (record) {
+      bytes -= record.bytes;
+      records.delete(id);
+    }
+  }
+  function expire() {
+    for (const [id, record] of records)
+      if (clock.now() >= record.expiresAt) remove(id);
+  }
+  function get(id) {
+    expire();
+    const record = records.get(id);
+    if (!record) return undefined;
+    records.delete(id);
+    records.set(id, record);
+    return JSON.parse(record.json);
+  }
+  return {
+    get,
+    put(record) {
+      expire();
+      const json = JSON.stringify(record);
+      const size = Buffer.byteLength(json);
+      if (size > maxBytes) return false;
+      remove(record.id);
+      while (records.size >= maxEntries || bytes + size > maxBytes)
+        remove(records.keys().next().value);
+      const now = clock.now();
+      const completedAt =
+        Number.isSafeInteger(record.finishedAt) && record.finishedAt >= 0
+          ? Math.min(record.finishedAt, now)
+          : now;
+      records.set(record.id, {
+        json,
+        bytes: size,
+        expiresAt: completedAt + ttlMs,
+      });
+      bytes += size;
+      return true;
+    },
+    findKey(key) {
+      expire();
+      for (const [id, record] of records) {
+        const item = JSON.parse(record.json);
+        if (item.key === key && reusable(item)) return get(id);
+      }
+    },
+    get bytes() {
+      expire();
+      return bytes;
+    },
+    get size() {
+      expire();
+      return records.size;
+    },
+  };
+}

package/dist/server/worker.mjs

@@ -0,0 +1,57 @@
+import { lstat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { parsePackageSpec } from "../core/acquire.mjs";
+import { validateReport } from "../core/report.mjs";
+
+export async function workerMain() {
+  let input = "";
+  for await (const chunk of process.stdin) {
+    if (Buffer.byteLength(input) + chunk.length > 8192)
+      throw new Error("invalid-worker-request");
+    input += chunk.toString("utf8");
+  }
+  const request = JSON.parse(input);
+  if (
+    !request ||
+    typeof request !== "object" ||
+    Array.isArray(request) ||
+    Object.keys(request).some(
+      (key) => !["spec", "workDir", "maxResultBytes"].includes(key),
+    ) ||
+    typeof request.workDir !== "string" ||
+    request.workDir !== process.cwd() ||
+    !/^job-[a-f0-9]{32}$/.test(path.basename(request.workDir)) ||
+    !Number.isSafeInteger(request.maxResultBytes) ||
+    request.maxResultBytes < 1 ||
+    request.maxResultBytes > 67108864
+  )
+    throw new Error("invalid-worker-request");
+  parsePackageSpec(request.spec);
+  const stat = await lstat(request.workDir);
+  if (!stat.isDirectory() || stat.isSymbolicLink() || stat.mode & 0o077)
+    throw new Error("invalid-worker-directory");
+  const { analyzeRegistry } = await import("../core/online.mjs");
+  const report = validateReport(
+    await analyzeRegistry(request.spec, {
+      workDir: request.workDir,
+      persistCache: false,
+    }),
+  );
+  report.run.surface = "web";
+  const result = JSON.stringify(report);
+  if (Buffer.byteLength(result) > request.maxResultBytes)
+    throw new Error("analysis-result-cap");
+  await writeFile(path.join(request.workDir, "report.json"), result, {
+    flag: "wx",
+    mode: 0o600,
+  });
+}
+
+if (
+  process.argv[1] &&
+  pathToFileURL(path.resolve(process.argv[1])).href === import.meta.url
+)
+  workerMain().catch(() => {
+    process.exitCode = 1;
+  });

package/dist/version.json

@@ -0,0 +1 @@
+{"buildSchema":"1","version":"0.1.0","dirty":false,"commit":"f011778208a3482298332e925953af6801c358b2","sourceSha256":"fb3242f543b59e7c0655e87588dcc57b1ecf43ee099dfc762bd6f052b5ea537d","packageSha256":"3ab84be2e0a0d13b691a655dec4be52ab6c08ca8d4d87f32688aea76588ecfdc","lockfileSha256":"7d00d517bc2fc689d89a91e5488505bbe9b7e64a352c3dc72ea4bd84d9dd0f97","files":{"cli/hosted.mjs":{"sha256":"dea7b512a2e811102521565e9f218c77aab916fe05e838f55a9aeb7b43cd0852","size":7436},"cli/main.mjs":{"sha256":"3bff23e18025d73dbfd8eb3a9571a7797702f03ed14e8d2d1edd6a12304c579e","size":6597},"core/acquire.mjs":{"sha256":"aee5ed002292edf1b03385ceec8ebfb03de452dba36bbdced96f888eaafa1d67","size":9549},"core/archive.mjs":{"sha256":"80aa4373c0324458fe322a83af18a4cfd0ffec4b39ebdeffc9084639a8655410","size":16193},"core/compare.mjs":{"sha256":"540614266e06a2875010793d036d256ddfac72f978157cd3d147ffb99015d8e4","size":7579},"core/manifests.mjs":{"sha256":"29c40e01ff1e1dfaed444600d8c78380d23d4bc9be71960251e39ea3594de2f1","size":17891},"core/online.mjs":{"sha256":"368a3f2558e16db0701d2eaf068b48e2661e7e01ab7cf5605cdd22766aeb5cca","size":9741},"core/pipeline.mjs":{"sha256":"9c4ddc5c258a99455a1230c978fd132c135057ad7bb6c7baa201ae530ee136fd","size":11060},"core/policy.mjs":{"sha256":"4281c626c00a6424992f5e1eba26876e2b70f4b968450a8ca52fa42f5a121ba5","size":2954},"core/report.mjs":{"sha256":"aa167c94c257a5ff6d830630a37a51a9a9e47f82aa4a0a7b96ead91a5967294b","size":15844},"core/resolve.mjs":{"sha256":"d5575da49ff78e8fea8df1f2fc10a39540adea285eddfa347746e848f9fdf957","size":5202},"core/source.mjs":{"sha256":"798fe74e3fba836b82576cd46e1b91e6f6e0a4e3cf273c533b5e074247c81373","size":3238},"core/syntax.mjs":{"sha256":"2d50f2e73e17aedbcbccd92af280e171de4ef78b55acccd23d6b6ef11e891776","size":10450},"model/client.mjs":{"sha256":"ddda56b2080d6508ba85e105d21d3709dee07b80ed4ca8c492c824456205b422","size":41854},"model/config.mjs":{"sha256":"127605979a299616be15f4a47e94dcd82928b00ad2af71744ffaa6e359516486","size":3245},"server/app.mjs":{"sha256":"36c265269bdf3f063e98997f26efed077b2b3a3113e709b06a91af69d8376b3c","size":9392},"server/main.mjs":{"sha256":"bffc78cbb973d0dd9900bbdc307d86b15de91b1ea2b0f312a16c2b673a0801bc","size":4044},"server/queue.mjs":{"sha256":"37290655ef70c35383381ec5e76f10922b918f40224fca51a92abd714c095cf7","size":5094},"server/runner.mjs":{"sha256":"a6ca5bfbd7b239f7110639d854ca9a263f4cf3aaf06701ea54493b29f8244706","size":9071},"server/store.mjs":{"sha256":"efa2a35c7e9d0344c26e24ba360a457cdf80f4f48975f0186f81844b9fb7a097","size":2706},"server/worker.mjs":{"sha256":"1df839608cd1c691fc2801d89e698daeef3e48d7f4b8843ce1252a21fde9730a","size":1902},"viewer/render.mjs":{"sha256":"c77442c27041a5fe28269b8c80c9d24c72b73a226e8d4491e6d7285a9feb5309","size":19443},"viewer/shell.mjs":{"sha256":"5f800d0a97fe416d02cf9abef766d651b444b4745ad3a998926599469358ca79","size":9408}}}