@prismatic-io/lux 0.0.1

package/src/orchestrator/owned-lock.ts

@@ -0,0 +1,147 @@
+import { randomInt, randomUUID } from "node:crypto";
+import { link, lstat, open, readdir, readFile, rm, unlink } from "node:fs/promises";
+import { hostname } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+
+export type LockRecoveryClaim = {
+  path: string;
+  removeLock: () => Promise<boolean>;
+  release: () => Promise<void>;
+};
+
+const missingAsNull = <Value>(promise: Promise<Value>): Promise<Value | null> =>
+  promise.catch((error: NodeJS.ErrnoException) => {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  });
+
+const unlinkIfExists = async (path: string): Promise<boolean> => {
+  try {
+    await unlink(path);
+    return true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+    throw error;
+  }
+};
+
+/** Publish a complete owner record without ever exposing a partial lock file. */
+export const publishOwnedLock = async <Owner extends object>(
+  lockPath: string,
+  owner: Owner,
+): Promise<Owner & { lockToken: string }> => {
+  const lockToken = randomUUID();
+  const acquired = { ...owner, lockToken };
+  const temporary = `${lockPath}.${process.pid}.${lockToken}.tmp`;
+  const handle = await open(temporary, "wx");
+  try {
+    try {
+      await handle.writeFile(`${JSON.stringify(acquired)}\n`);
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await link(temporary, lockPath);
+    return acquired;
+  } finally {
+    await rm(temporary, { force: true });
+  }
+};
+
+const linkedClaim = (lockPath: string, claimPath: string): LockRecoveryClaim => ({
+  path: claimPath,
+  removeLock: async () => {
+    const [lock, claim] = await Promise.all([missingAsNull(lstat(lockPath)), lstat(claimPath)]);
+    if (!lock) return false;
+    if (lock.dev !== claim.dev || lock.ino !== claim.ino) return false;
+    return unlinkIfExists(lockPath);
+  },
+  release: () => rm(claimPath, { force: true }),
+});
+
+const recoveryHost = Buffer.from(hostname()).toString("base64url");
+
+const localClaimProcessIsDead = (prefix: string, name: string): boolean => {
+  const [claimHost, rawPid, id, extra] = name.slice(prefix.length).split(".");
+  if (claimHost !== recoveryHost || !rawPid || !id || extra !== undefined) return false;
+  try {
+    process.kill(Number(rawPid), 0);
+    return false;
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code === "ESRCH";
+  }
+};
+
+const hasCompetingRecoveryClaim = async (lockPath: string, claimPath: string): Promise<boolean> => {
+  const claim = await lstat(claimPath);
+  const directory = dirname(lockPath);
+  const claimName = basename(claimPath);
+  const prefix = `${basename(lockPath)}.recovering-`;
+  for (const name of await readdir(directory)) {
+    if (name === claimName || !name.startsWith(prefix)) continue;
+    const peerPath = join(directory, name);
+    const peer = await missingAsNull(lstat(peerPath));
+    if (!peer || peer.dev !== claim.dev || peer.ino !== claim.ino) continue;
+    if (localClaimProcessIsDead(prefix, name)) {
+      await unlinkIfExists(peerPath);
+      continue;
+    }
+    return true;
+  }
+  return false;
+};
+
+/**
+ * Bind stale-lock recovery to one inode and admit at most one live recoverer.
+ * Foreign claims stay conservative because foreign lock owners do too.
+ */
+export const claimLockForRecovery = async (lockPath: string): Promise<LockRecoveryClaim | null> => {
+  const claimPath = `${lockPath}.recovering-${recoveryHost}.${process.pid}.${randomUUID()}`;
+  try {
+    await link(lockPath, claimPath);
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code === "ENOENT") return null;
+    throw error;
+  }
+  const claim = linkedClaim(lockPath, claimPath);
+  try {
+    if (!(await hasCompetingRecoveryClaim(lockPath, claimPath))) return claim;
+  } catch (error) {
+    await claim.release();
+    throw error;
+  }
+  await claim.release();
+  await delay(randomInt(1, 8));
+  return null;
+};
+
+/** Remove only the canonical lock that still carries this acquisition token. */
+export const releaseOwnedLock = async (lockPath: string, lockToken: string): Promise<boolean> => {
+  const claimPath = `${lockPath}.release-${lockToken}`;
+  try {
+    await link(lockPath, claimPath);
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code === "EEXIST" || code === "ENOENT") return false;
+    throw error;
+  }
+  const claim = linkedClaim(lockPath, claimPath);
+  try {
+    let currentToken: unknown;
+    try {
+      const value = JSON.parse(await readFile(claim.path, "utf8")) as unknown;
+      currentToken =
+        value && typeof value === "object"
+          ? (value as { lockToken?: unknown }).lockToken
+          : undefined;
+    } catch {
+      return false;
+    }
+    if (currentToken !== lockToken) return false;
+    return await claim.removeLock();
+  } finally {
+    await claim.release();
+  }
+};

package/src/orchestrator/package-version.ts

@@ -0,0 +1,5 @@
+import { createRequire } from "node:module";
+
+const requireFromHere = createRequire(import.meta.url);
+
+export const LUX_VERSION = (requireFromHere("../../package.json") as { version: string }).version;

package/src/orchestrator/provenance.ts

@@ -0,0 +1,140 @@
+import { existsSync } from "node:fs";
+import { lstat, readFile, readlink } from "node:fs/promises";
+import { dirname, join, parse, relative, resolve, sep } from "node:path";
+import type { RunProvenance } from "../core/index.js";
+import { contentHash, exec, valueHash } from "../core/index.js";
+
+type GitState = NonNullable<NonNullable<RunProvenance["source"]>["git"]>;
+const repositories = new Map<string, Promise<GitState | undefined>>();
+const MAX_WORKING_TREE_IDENTITY_BYTES = 10_000_000;
+const portablePath = (path: string): string => path.split(sep).join("/");
+
+const gitRootAbove = (path: string): string | null => {
+  let dir = resolve(path);
+  if (!existsSync(dir)) dir = dirname(dir);
+  const root = parse(dir).root;
+  while (true) {
+    if (existsSync(join(dir, ".git"))) return dir;
+    if (dir === root) return null;
+    dir = dirname(dir);
+  }
+};
+
+const inspectRepository = async (root: string): Promise<GitState | undefined> => {
+  try {
+    const [head, status, diff, untracked] = await Promise.all([
+      exec("git", ["rev-parse", "HEAD"], { cwd: root, timeoutMs: 5_000 }),
+      exec("git", ["status", "--porcelain=v1", "--untracked-files=normal"], {
+        cwd: root,
+        timeoutMs: 5_000,
+      }),
+      exec("git", ["diff", "--no-ext-diff", "--no-textconv", "--binary", "HEAD", "--"], {
+        cwd: root,
+        timeoutMs: 5_000,
+        maxBuffer: MAX_WORKING_TREE_IDENTITY_BYTES,
+      }),
+      exec("git", ["ls-files", "--others", "--exclude-standard", "-z"], {
+        cwd: root,
+        timeoutMs: 5_000,
+        maxBuffer: MAX_WORKING_TREE_IDENTITY_BYTES,
+      }),
+    ]);
+    if (head.exitCode !== 0 || head.timedOut || status.exitCode !== 0 || status.timedOut) {
+      return undefined;
+    }
+    const state: GitState = {
+      commit: head.stdout.trim(),
+      dirty: status.stdout.trim().length > 0,
+    };
+    if (!state.dirty) return state;
+    try {
+      if (
+        diff.exitCode !== 0 ||
+        diff.timedOut ||
+        diff.stdoutTruncated ||
+        untracked.exitCode !== 0 ||
+        untracked.timedOut ||
+        untracked.stdoutTruncated
+      ) {
+        return state;
+      }
+
+      let identityBytes = Buffer.byteLength(diff.stdout) + Buffer.byteLength(untracked.stdout);
+      const untrackedFiles: Array<{
+        path: string;
+        kind: "file" | "symlink" | "special";
+        mode: number;
+        contentHash?: string;
+        target?: string;
+      }> = [];
+      for (const path of untracked.stdout.split("\0").filter(Boolean).sort()) {
+        const absolute = resolve(root, path);
+        const fromRoot = relative(root, absolute);
+        if (fromRoot === ".." || fromRoot.startsWith(`..${sep}`)) return state;
+        const stat = await lstat(absolute);
+        if (stat.isFile()) {
+          identityBytes += stat.size;
+          if (identityBytes > MAX_WORKING_TREE_IDENTITY_BYTES) return state;
+          untrackedFiles.push({
+            path,
+            kind: "file",
+            mode: stat.mode,
+            contentHash: contentHash(await readFile(absolute)),
+          });
+        } else if (stat.isSymbolicLink()) {
+          const target = await readlink(absolute);
+          identityBytes += Buffer.byteLength(target);
+          if (identityBytes > MAX_WORKING_TREE_IDENTITY_BYTES) return state;
+          untrackedFiles.push({ path, kind: "symlink", mode: stat.mode, target });
+        } else {
+          untrackedFiles.push({ path, kind: "special", mode: stat.mode });
+        }
+      }
+      return {
+        ...state,
+        workingTreeHash: valueHash({
+          trackedDiffHash: contentHash(diff.stdout),
+          untrackedFiles,
+        }),
+      };
+    } catch {
+      // A file can disappear while Git state is being sampled. Preserve the
+      // commit/dirty provenance and let comparison treat the missing content
+      // identity conservatively.
+      return state;
+    }
+  } catch {
+    return undefined;
+  }
+};
+
+export const runtimeIdentity = (): RunProvenance["runtime"] => ({
+  platform: process.platform,
+  arch: process.arch,
+  node: process.version,
+  ...(process.versions.bun ? { bun: process.versions.bun } : {}),
+});
+
+export const runProvenance = async (casePath: string | null): Promise<RunProvenance> => {
+  const runtime = runtimeIdentity();
+  if (!casePath) return { runtime };
+  const root = gitRootAbove(casePath);
+  if (!root) return { runtime, source: { casePath: resolve(casePath) } };
+  let git = repositories.get(root);
+  if (!git) {
+    git = inspectRepository(root);
+    repositories.set(root, git);
+  }
+  const state = await git;
+  return {
+    runtime,
+    source: {
+      casePath: portablePath(relative(root, resolve(casePath))),
+      ...(state ? { git: state } : {}),
+    },
+  };
+};
+
+export const clearProvenanceCache = (): void => {
+  repositories.clear();
+};