Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

chore(deps): detect stale direct dependency installs

morlutoad398a17f551
diff --git a/scripts/check-dependency-install.mjs b/scripts/check-dependency-install.mjs
new file mode 100644
index 000000000..e3b9fbffd
--- /dev/null
+++ b/scripts/check-dependency-install.mjs
@@ -0,0 +1,60 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+
+const REMEDIATION = "Run `npm ci`, then retry.";
+
+const readJson = async (path) => JSON.parse(await readFile(path, "utf8"));
+
+const directDependencies = (rootPackage) => ({
+ ...rootPackage.dependencies,
+ ...rootPackage.devDependencies,
+});
+
+const installedPackageKey = (name) => `node_modules/${name}`;
+
+/** Compare root direct dependencies with npm's hidden installed lockfile. */
+export const dependencyInstallProblems = (rootLock, installedLock) => {
+ const rootPackage = rootLock.packages?.[""];
+ if (rootPackage === undefined)
+ return ["package-lock.json does not contain a root package entry"];
+ const installedPackages = installedLock.packages ?? {};
+ return Object.keys(directDependencies(rootPackage))
+ .sort()
+ .flatMap((name) => {
+ const key = installedPackageKey(name);
+ const expected = rootLock.packages?.[key]?.version;
+ const actual = installedPackages[key]?.version;
+ if (expected === undefined)
+ return [`${name}: missing resolved version in package-lock.json`];
+ if (actual === undefined)
+ return [`${name}: missing from the installed dependency lockfile`];
+ return actual === expected
+ ? []
+ : [`${name}: installed ${actual}, expected ${expected}`];
+ });
+};
+
+const main = async () => {
+ const root = process.cwd();
+ try {
+ const [rootLock, installedLock] = await Promise.all([
+ readJson(resolve(root, "package-lock.json")),
+ readJson(resolve(root, "node_modules/.package-lock.json")),
+ ]);
+ const problems = dependencyInstallProblems(rootLock, installedLock);
+ if (problems.length === 0) return;
+ process.stderr.write(
+ `Direct dependency installation is stale:\n${problems.map((problem) => `- ${problem}`).join("\n")}\n${REMEDIATION}\n`,
+ );
+ process.exitCode = 1;
+ } catch (error) {
+ const reason =
+ error instanceof Error ? error.message : "unreadable lockfile";
+ process.stderr.write(
+ `Could not verify the installed direct dependencies: ${reason}\n${REMEDIATION}\n`,
+ );
+ process.exitCode = 1;
+ }
+};
+
+if (process.argv[1] === new URL(import.meta.url).pathname) await main();
diff --git a/tests/dependencyInstall.test.ts b/tests/dependencyInstall.test.ts
new file mode 100644
index 000000000..46e6da91e
--- /dev/null
+++ b/tests/dependencyInstall.test.ts
@@ -0,0 +1,82 @@
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+const roots: string[] = [];
+const script = join(process.cwd(), "scripts", "check-dependency-install.mjs");
+
+afterEach(async () => {
+ await Promise.all(
+ roots.splice(0).map((root) => rm(root, { recursive: true })),
+ );
+});
+
+const fixture = async (
+ installedVersion?: string,
+ omitDevDependency = false,
+) => {
+ const root = await mkdtemp(join(tmpdir(), "rea-deps-"));
+ roots.push(root);
+ await mkdir(join(root, "node_modules"));
+ await writeFile(
+ join(root, "package-lock.json"),
+ JSON.stringify({
+ packages: {
+ "": {
+ dependencies: { alpha: "1.0.0" },
+ devDependencies: { beta: "2.0.0" },
+ },
+ "node_modules/alpha": { version: "1.0.0" },
+ "node_modules/beta": { version: "2.0.0" },
+ },
+ }),
+ );
+ await writeFile(
+ join(root, "node_modules", ".package-lock.json"),
+ JSON.stringify({
+ packages: {
+ "node_modules/alpha": { version: installedVersion ?? "1.0.0" },
+ ...(omitDevDependency
+ ? {}
+ : { "node_modules/beta": { version: "2.0.0" } }),
+ "node_modules/unrelated": { version: "9.0.0" },
+ },
+ }),
+ );
+ return root;
+};
+
+describe("dependency install freshness", () => {
+ it("accepts matching direct packages and ignores extraneous packages", async () => {
+ const result = spawnSync(process.execPath, [script], {
+ cwd: await fixture(),
+ encoding: "utf8",
+ });
+ expect(result.status, result.stderr).toBe(0);
+ });
+
+ it("reports a direct version mismatch with one remediation", async () => {
+ const result = spawnSync(process.execPath, [script], {
+ cwd: await fixture("0.9.0"),
+ encoding: "utf8",
+ });
+ expect(result.status).toBe(1);
+ expect(result.stderr).toContain("alpha: installed 0.9.0, expected 1.0.0");
+ expect(result.stderr.match(/npm ci/gu)).toHaveLength(1);
+ });
+
+ it("reports a missing direct development dependency", async () => {
+ const result = spawnSync(process.execPath, [script], {
+ cwd: await fixture(undefined, true),
+ encoding: "utf8",
+ });
+ expect(result.status).toBe(1);
+ expect(result.stderr).toContain(
+ "beta: missing from the installed dependency lockfile",
+ );
+ expect(result.stderr.match(/npm ci/gu)).toHaveLength(1);
+ });
+});