From f57e4dc765e85b47f39e5271fd7712cbea572b32 Mon Sep 17 00:00:00 2001 From: JSONbored <49853598+JSONbored@users.noreply.github.com> Date: Tue, 21 Jul 2026 01:27:47 -0700 Subject: [PATCH 1/2] ci(build): catch stale committed miner/mcp compiled output before merge packages/loopover-miner and packages/loopover-mcp compile real TypeScript in place and commit the emitted .js/.d.ts (both ship as installable CLIs, so a runnable .js has to exist without a build step). Nothing enforced that the committed output actually matched a fresh build: root-level tests import the emitted .js by its literal specifier, and the job that builds these packages runs as a separate GitHub Actions job from the one that tests them, so a contributor who edited .ts without rebuilding got tests silently running old behavior with zero CI signal -- the same drift class the Selfhost/Miner env-reference checks were previously added to close. Adds scripts/check-build-drift.mjs (git-status-based, so a compiled file that was never committed at all is caught too, not just a stale one), wires it into ci.yml right after each package's real build step, and into package.json's local test:ci for pre-push parity. Also fixes three comments left stale by the #7290/#7291 TypeScript migrations completing, and adds loopover-mcp's missing migration-complete guard test (mirroring loopover-miner's existing one). --- .../skills/contributing-to-loopover/SKILL.md | 6 +- .github/workflows/ci.yml | 30 ++++- .github/workflows/publish-miner.yml | 10 +- package.json | 4 +- packages/loopover-mcp/tsconfig.json | 6 +- scripts/check-build-drift.d.mts | 8 ++ scripts/check-build-drift.mjs | 62 +++++++++ test/unit/check-build-drift-script.test.ts | 120 ++++++++++++++++++ .../mcp-typescript-migration-complete.test.ts | 43 +++++++ 9 files changed, 275 insertions(+), 14 deletions(-) create mode 100644 scripts/check-build-drift.d.mts create mode 100644 scripts/check-build-drift.mjs create mode 100644 test/unit/check-build-drift-script.test.ts create mode 100644 test/unit/mcp-typescript-migration-complete.test.ts diff --git a/.claude/skills/contributing-to-loopover/SKILL.md b/.claude/skills/contributing-to-loopover/SKILL.md index 3d3674704b..7a81638fd6 100644 --- a/.claude/skills/contributing-to-loopover/SKILL.md +++ b/.claude/skills/contributing-to-loopover/SKILL.md @@ -221,9 +221,9 @@ npm audit --audit-level=moderate # the dependency-review job's local eq `npm run test:ci` runs, and must pass, **all of**: `actionlint`, `db:migrations:check`, `db:schema-drift:check`, `selfhost:env-reference:check`, `selfhost:validate-observability`, -`cf-typegen:check`, `typecheck`, `test:coverage`, `test:engine-parity`, `test:live-gate-parity`, `test:driver-parity`, the -`@loopover/engine` workspace's own test run, `test:workers`, `build:mcp`, `test:mcp-pack`, -`build:miner`, `test:miner-pack`, `rees:test`, `ui:openapi:check`, `ui:openapi:settings-parity`, +`cf-typegen:check`, `build:mcp:check`, `build:miner:check`, `typecheck`, `test:coverage`, `test:engine-parity`, `test:live-gate-parity`, `test:driver-parity`, the +`@loopover/engine` workspace's own test run, `test:workers`, `test:mcp-pack`, +`test:miner-pack`, `rees:test`, `ui:openapi:check`, `ui:openapi:settings-parity`, `ui:version-audit`, `docs:drift-check`, `manifest:drift-check`, `engine-parity:drift-check`, `command-reference:check`, `ui:lint`, `ui:typecheck`, `ui:test`, `ui:build`. If any step fails, fix it and re-run — do not push a red tree. (Full per-check table in `reference.md`; check `package.json`'s diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ee8856f07a..79ff4be51e 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -470,13 +470,29 @@ jobs: - name: Build MCP if: ${{ github.event_name == 'push' || needs.changes.outputs.mcp == 'true' || needs.changes.outputs.engine == 'true' }} run: npx turbo run build --filter=@loopover/mcp + # packages/loopover-mcp/{bin,lib} compile real TypeScript in place (tsc's outDir === rootDir, so + # e.g. lib/foo.ts emits lib/foo.js right next to it) and commit that emitted output -- the package + # ships as an installable CLI (npm install -g), so a runnable .js has to exist in the published + # tarball, and test/**/*.test.ts imports the emitted .js by its literal specifier, not the .ts + # source. "Build MCP" above (this job) and the "Test with coverage" job below run as separate GitHub + # Actions jobs with independent checkouts, so nothing in this job's build step can ever self-heal a + # stale commit before the coverage job's tests run against it -- a contributor who edits .ts and + # forgets to rebuild+commit the .js gets tests silently exercising old behavior with no CI signal, + # same drift-class gap the Selfhost/Miner env-reference checks above were added to close. This + # fails loudly instead: the build one step up already regenerated bin/lib in place, so any git + # status output here means the committed .js/.d.ts didn't match what that build just produced. + - name: MCP build drift check + if: ${{ github.event_name == 'push' || needs.changes.outputs.mcp == 'true' || needs.changes.outputs.engine == 'true' }} + run: node scripts/check-build-drift.mjs mcp - name: MCP package check if: ${{ github.event_name == 'push' || needs.changes.outputs.mcp == 'true' || needs.changes.outputs.engine == 'true' }} run: npm run test:mcp-pack - # Invokes turbo.json's @loopover/miner#build:tsc (cache: false, since its committed lib/**/*.js - # output can't be safely restored without risking a stomp of hand-written files) and - # @loopover/miner#build:verify (real caching win: skips re-`node --check`-ing all 121 bin/lib files - # when neither changed) DIRECTLY as their own task names, deliberately NOT via the aggregate + # Invokes turbo.json's @loopover/miner#build:tsc (cache: false -- historically to avoid a cache + # restore stomping this package's hand-written .js files while the #7290 migration was still + # in-flight; now that #7317 closed it out, every bin/lib file is compiler-owned and that original + # risk no longer applies, but re-enabling caching here is a separate change this PR doesn't make) + # and @loopover/miner#build:verify (real caching win: skips re-`node --check`-ing all 121 bin/lib + # files when neither changed) DIRECTLY as their own task names, deliberately NOT via the aggregate # `@loopover/miner#build` task (which exists for standalone/local `npm run build` callers) -- that # aggregate's own script is `npm run build:tsc && npm run build:verify`, i.e. it re-invokes both of # these exact scripts a second time even when turbo already ran them as cached prerequisite tasks @@ -488,6 +504,12 @@ jobs: - name: Build miner CLI if: ${{ github.event_name == 'push' || needs.changes.outputs.miner == 'true' || needs.changes.outputs.engine == 'true' }} run: npx turbo run build:tsc build:verify --filter=@loopover/miner + # Same "separate job, no self-heal" drift-class gap as MCP's own build drift check above, and the + # ORIGINAL motivating case for it: packages/loopover-miner/lib/cross-repo-evaluation.{ts,js,d.ts} + # are real files a contributor edits directly, not obscure internals. + - name: Miner build drift check + if: ${{ github.event_name == 'push' || needs.changes.outputs.miner == 'true' || needs.changes.outputs.engine == 'true' }} + run: node scripts/check-build-drift.mjs miner # loopover-miner depends on @loopover/engine for real too (same relationship as loopover-mcp above # -- packages/loopover-miner/package.json lists it as a dependency), so this and "Build miner CLI" # above now also trigger on an engine-only PR, matching "Build MCP"/"MCP package check"'s existing diff --git a/.github/workflows/publish-miner.yml b/.github/workflows/publish-miner.yml index 3f97b3c74f..7b9742b169 100644 --- a/.github/workflows/publish-miner.yml +++ b/.github/workflows/publish-miner.yml @@ -89,9 +89,13 @@ jobs: - name: Install dependencies run: npm ci - # Miner ships hand-written, checked-in JS (no tsc build) -- "build" here is node --check syntax - # validation over every bin/lib file, the same script test:ci already runs on every PR. - - name: Miner syntax validation + # Real tsc build (in-place emit -- see packages/loopover-miner/tsconfig.json), same as ci.yml's own + # "Build miner CLI" step, followed by node --check syntax validation over every bin/lib file (the + # same two-part script test:ci already runs on every PR). Re-running the compile here means this + # job always packs from a freshly-built tree even if the tagged commit's committed .js/.d.ts had + # somehow drifted from its .ts source (ci.yml's build-drift check on every PR is what keeps that + # from happening in the first place). + - name: Miner build + syntax validation run: npm run build --workspace @loopover/miner # Reuses the exact allowlist/required-files/forbidden-content check test:ci already runs on diff --git a/package.json b/package.json index 310762f59b..3e613fad64 100644 --- a/package.json +++ b/package.json @@ -33,7 +33,9 @@ "db:migrate:remote": "wrangler d1 migrations apply loopover --remote", "drizzle:generate": "drizzle-kit generate", "build:mcp": "npm --workspace @loopover/mcp run build", + "build:mcp:check": "npm run build:mcp && node scripts/check-build-drift.mjs mcp", "build:miner": "turbo run build --filter=@loopover/engine && npm --workspace @loopover/miner run build", + "build:miner:check": "npm run build:miner && node scripts/check-build-drift.mjs miner", "test:mcp-pack": "node scripts/check-mcp-package.mjs", "test:miner-pack": "node scripts/check-miner-package.mjs", "test:miner-deployment-docs-audit": "node scripts/check-miner-deployment-docs.mjs", @@ -109,7 +111,7 @@ "test:smoke:browser:install": "playwright install chromium", "test:smoke:browser": "node scripts/smoke-ui-browser.mjs", "pretest:ci": "npm run check-node-version", - "test:ci": "git diff --check && npm run actionlint && npm run lint:composite-actions && npm run db:migrations:check && npm run db:schema-drift:check && npm run selfhost:env-reference:check && npm run miner:env-reference:check && npm run selfhost:validate-observability && npm run cf-typegen:check && npm run build --workspace @loopover/engine && npm run build --workspace @loopover/discovery-index && npm run typecheck && npm run test:coverage && npm run test:engine-parity && npm run test:live-gate-parity && npm run test:driver-parity && npm run test --workspace @loopover/engine && npm run test:workers && npm run build:mcp && npm run test:mcp-pack && npm run build:miner && npm run test:miner-pack && npm run test:miner-deployment-docs-audit && npm run rees:test && npm run ui:openapi:check && npm run ui:openapi:settings-parity && npm run ui:version-audit && npm run docs:drift-check && npm run branding-drift:check && npm run manifest:drift-check && npm run engine-parity:drift-check && npm run engines-nvmrc:check && npm run release-manifest:sync:check && npm run command-reference:check && npm run ui:lint && npm run ui:typecheck && npm run ui:test && npm run ui:build", + "test:ci": "git diff --check && npm run actionlint && npm run lint:composite-actions && npm run db:migrations:check && npm run db:schema-drift:check && npm run selfhost:env-reference:check && npm run miner:env-reference:check && npm run selfhost:validate-observability && npm run cf-typegen:check && npm run build:mcp:check && npm run build:miner:check && npm run build --workspace @loopover/engine && npm run build --workspace @loopover/discovery-index && npm run typecheck && npm run test:coverage && npm run test:engine-parity && npm run test:live-gate-parity && npm run test:driver-parity && npm run test --workspace @loopover/engine && npm run test:workers && npm run test:mcp-pack && npm run test:miner-pack && npm run test:miner-deployment-docs-audit && npm run rees:test && npm run ui:openapi:check && npm run ui:openapi:settings-parity && npm run ui:version-audit && npm run docs:drift-check && npm run branding-drift:check && npm run manifest:drift-check && npm run engine-parity:drift-check && npm run engines-nvmrc:check && npm run release-manifest:sync:check && npm run command-reference:check && npm run ui:lint && npm run ui:typecheck && npm run ui:test && npm run ui:build", "test:release": "npm run test:ci && npm run changelog:check", "test:release:mcp": "npm run test:ci", "test:watch": "vitest", diff --git a/packages/loopover-mcp/tsconfig.json b/packages/loopover-mcp/tsconfig.json index 3345a971fd..63895b7219 100644 --- a/packages/loopover-mcp/tsconfig.json +++ b/packages/loopover-mcp/tsconfig.json @@ -24,9 +24,9 @@ // repo root and corrupt each other's incremental state. "tsBuildInfoFile": "./.tsbuildinfo" }, - // Only files already converted to real TypeScript are included -- everything else in bin/lib stays - // plain, hand-maintained .js until its own migration phase lands (#7291). No edits needed here as - // later phases convert more files: the glob picks them up automatically. + // Every bin/lib runtime module is real TypeScript (#7291, phased across #7328/#7329/#7330): tsc owns + // the in-place .js emit. The glob stays the include surface; test/unit/mcp-typescript-migration-complete.test.ts + // fails closed if a hand-maintained .js orphan ever reappears. "include": ["bin/**/*.ts", "lib/**/*.ts"], // Without this, tsc's default exclude list (which always adds outDir) resolves to "." -- the whole // package root -- and silently excludes every include match, since outDir is "." for in-place emit. diff --git a/scripts/check-build-drift.d.mts b/scripts/check-build-drift.d.mts new file mode 100644 index 0000000000..a04bbb4384 --- /dev/null +++ b/scripts/check-build-drift.d.mts @@ -0,0 +1,8 @@ +export function pathsForPackage(name: string): string[]; + +export function checkBuildDrift( + paths: string[], + options?: { cwd?: string; run?: (paths: string[], cwd: string) => string }, +): string; + +export function main(argv: string[]): void; diff --git a/scripts/check-build-drift.mjs b/scripts/check-build-drift.mjs new file mode 100644 index 0000000000..cdee307a32 --- /dev/null +++ b/scripts/check-build-drift.mjs @@ -0,0 +1,62 @@ +#!/usr/bin/env node +// packages/loopover-{miner,mcp} both compile real TypeScript in place (tsc's outDir === rootDir, so +// e.g. lib/foo.ts emits lib/foo.js + lib/foo.d.ts right next to it) and commit that emitted output -- +// both packages ship as installable CLIs (npm install -g), so a runnable .js has to exist in the +// published tarball, and root-level tests import the emitted .js by its literal specifier (NodeNext +// resolution), not the .ts source, so a stale commit makes test:coverage silently exercise old +// behavior instead of loudly failing. package.json composes this AFTER the package's real build +// (`npm run build:{miner,mcp} && node scripts/check-build-drift.mjs {miner,mcp}`) -- this script's own +// job is just: did that build change anything relative to what's committed. Mirrors cf-typegen:check's +// "regenerate for real, then diff" shape for a package whose generated output is emitted in place +// across a whole directory rather than to one named file. +import { execFileSync } from "node:child_process"; +import { fileURLToPath } from "node:url"; + +const PACKAGE_PATHS = { + miner: ["packages/loopover-miner/bin", "packages/loopover-miner/lib"], + mcp: ["packages/loopover-mcp/bin", "packages/loopover-mcp/lib"], +}; + +/** The bin/lib directories a package name checks. Exported (rather than inlined into main()) so a test + * can validate the real PACKAGE_PATHS table itself -- e.g. that "miner" resolves to real repo paths -- + * not just a fake stand-in for it. Throws on an unknown name instead of silently checking nothing. */ +export function pathsForPackage(name) { + const paths = PACKAGE_PATHS[name]; + if (!paths) { + throw new Error(`check-build-drift: unknown package "${name}" (expected one of: ${Object.keys(PACKAGE_PATHS).join(", ")})`); + } + return paths; +} + +function defaultGitStatus(paths, cwd) { + return execFileSync("git", ["status", "--porcelain", "--", ...paths], { cwd, encoding: "utf8" }); +} + +/** Trimmed `git status --porcelain` text for `paths` under `cwd` (a real git worktree) -- "" when + * clean. Porcelain (not plain `git diff --exit-code`) deliberately: a .ts file whose emitted .js/.d.ts + * was never committed at all shows up as an untracked file, which `git diff` alone never reports. + * `run` is injectable so tests can fake the git call entirely; the default shells out for real. */ +export function checkBuildDrift(paths, { cwd = process.cwd(), run = defaultGitStatus } = {}) { + return run(paths, cwd).trim(); +} + +export function main(argv) { + try { + const name = argv[0]; + const paths = pathsForPackage(name); + const drift = checkBuildDrift(paths); + if (drift.length > 0) { + process.stderr.write( + `check-build-drift: packages/loopover-${name}'s committed .js/.d.ts is stale relative to its .ts source -- run \`npm run build:${name}\` and commit the result:\n${drift}\n`, + ); + process.exit(1); + return; + } + process.stdout.write(`check-build-drift: packages/loopover-${name}'s committed .js/.d.ts matches its .ts source.\n`); + } catch (err) { + process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`); + process.exit(1); + } +} + +if (process.argv[1] === fileURLToPath(import.meta.url)) main(process.argv.slice(2)); diff --git a/test/unit/check-build-drift-script.test.ts b/test/unit/check-build-drift-script.test.ts new file mode 100644 index 0000000000..e7ca0df9aa --- /dev/null +++ b/test/unit/check-build-drift-script.test.ts @@ -0,0 +1,120 @@ +import { execFileSync } from "node:child_process"; +import { mkdtempSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { afterEach, describe, expect, it } from "vitest"; +import { checkBuildDrift, pathsForPackage } from "../../scripts/check-build-drift.mjs"; + +const tmpDirs: string[] = []; +afterEach(() => { + for (const dir of tmpDirs.splice(0)) rmSync(dir, { recursive: true, force: true }); +}); + +function initScratchGitRepo(): string { + const dir = mkdtempSync(join(tmpdir(), "gtbuild-drift-")); + tmpDirs.push(dir); + const git = (...args: string[]) => execFileSync("git", args, { cwd: dir, encoding: "utf8" }); + git("init", "--quiet"); + git("-c", "user.email=test@example.com", "-c", "user.name=test", "-c", "commit.gpgsign=false", "commit", "--allow-empty", "-m", "init", "--quiet"); + return dir; +} + +describe("check-build-drift script", () => { + describe("pathsForPackage", () => { + it("resolves the real loopover-miner bin/lib paths", () => { + expect(pathsForPackage("miner")).toEqual(["packages/loopover-miner/bin", "packages/loopover-miner/lib"]); + }); + + it("resolves the real loopover-mcp bin/lib paths", () => { + expect(pathsForPackage("mcp")).toEqual(["packages/loopover-mcp/bin", "packages/loopover-mcp/lib"]); + }); + + it("throws a clear error for an unknown package name", () => { + expect(() => pathsForPackage("engine")).toThrow(/unknown package "engine".*miner.*mcp/s); + }); + }); + + describe("checkBuildDrift (injected run)", () => { + it("returns empty when the injected git status reports nothing", () => { + const drift = checkBuildDrift(["packages/loopover-miner/lib"], { run: () => "" }); + expect(drift).toBe(""); + }); + + it("trims and returns whatever the injected git status reports", () => { + const drift = checkBuildDrift(["packages/loopover-miner/lib"], { + run: () => "\n M packages/loopover-miner/lib/foo.js\n?? packages/loopover-miner/lib/foo.d.ts\n\n", + }); + expect(drift).toBe("M packages/loopover-miner/lib/foo.js\n?? packages/loopover-miner/lib/foo.d.ts"); + }); + + it("passes the paths and cwd it was given through to run", () => { + const calls: Array<{ paths: string[]; cwd: string }> = []; + checkBuildDrift(["bin", "lib"], { + cwd: "/fake/repo", + run: (paths, cwd) => { + calls.push({ paths, cwd }); + return ""; + }, + }); + expect(calls).toEqual([{ paths: ["bin", "lib"], cwd: "/fake/repo" }]); + }); + }); + + describe("checkBuildDrift (real git, scratch repo)", () => { + it("reports clean when nothing has changed since the last commit", () => { + const dir = initScratchGitRepo(); + expect(checkBuildDrift(["lib"], { cwd: dir })).toBe(""); + }); + + it("reports a modified tracked file (the 'stale committed .js' case)", () => { + const dir = initScratchGitRepo(); + const git = (...args: string[]) => execFileSync("git", args, { cwd: dir, encoding: "utf8" }); + writeFileSync(join(dir, "foo.js"), "export const x = 1;\n"); + git("add", "foo.js"); + git("-c", "user.email=test@example.com", "-c", "user.name=test", "-c", "commit.gpgsign=false", "commit", "-m", "add foo.js", "--quiet"); + + writeFileSync(join(dir, "foo.js"), "export const x = 2;\n"); + + expect(checkBuildDrift(["foo.js"], { cwd: dir })).toContain("foo.js"); + }); + + it("reports a brand new untracked file (the 'compiled output never committed' case)", () => { + // git diff --exit-code alone would miss this -- untracked files are invisible to `git diff`, + // which is exactly why this script uses `git status --porcelain` instead. + const dir = initScratchGitRepo(); + writeFileSync(join(dir, "bar.d.ts"), "export {};\n"); + + const drift = checkBuildDrift(["bar.d.ts"], { cwd: dir }); + + expect(drift).toContain("bar.d.ts"); + expect(drift.startsWith("??")).toBe(true); + }); + }); + + describe("CLI (real subprocess)", () => { + // Most important regression test in this file: proves the REAL currently-committed miner/mcp + // .js/.d.ts are not already stale relative to their .ts source -- if they were, this check would + // fail on `main` from the moment it merges. (Doesn't run the build itself -- npm run build:{miner,mcp} + // already ran as part of getting a green `npm run test:ci` locally before this change was committed.) + it("reports the real repo's loopover-miner output as clean", () => { + const output = execFileSync(process.execPath, ["scripts/check-build-drift.mjs", "miner"], { encoding: "utf8" }); + expect(output).toContain("packages/loopover-miner's committed .js/.d.ts matches its .ts source."); + }); + + it("reports the real repo's loopover-mcp output as clean", () => { + const output = execFileSync(process.execPath, ["scripts/check-build-drift.mjs", "mcp"], { encoding: "utf8" }); + expect(output).toContain("packages/loopover-mcp's committed .js/.d.ts matches its .ts source."); + }); + + it("exits non-zero with a clear message for an unknown package name", () => { + try { + execFileSync(process.execPath, ["scripts/check-build-drift.mjs", "engine"], { encoding: "utf8" }); + expect.unreachable("expected the CLI to exit non-zero for an unknown package name"); + } catch (err) { + const e = err as { status?: number; stdout?: string; stderr?: string }; + expect(e.status).toBe(1); + expect(`${e.stdout ?? ""}${e.stderr ?? ""}`).toContain('unknown package "engine"'); + } + }); + }); +}); diff --git a/test/unit/mcp-typescript-migration-complete.test.ts b/test/unit/mcp-typescript-migration-complete.test.ts new file mode 100644 index 0000000000..df77f896d6 --- /dev/null +++ b/test/unit/mcp-typescript-migration-complete.test.ts @@ -0,0 +1,43 @@ +import { readdirSync } from "node:fs"; +import { join } from "node:path"; +import { describe, expect, it } from "vitest"; + +const mcpRoot = join(process.cwd(), "packages/loopover-mcp"); +const dirs = ["bin", "lib"] as const; + +function listBasenames(dir: string, predicate: (name: string) => boolean): string[] { + return readdirSync(join(mcpRoot, dir)) + .filter(predicate) + .map((name) => name.replace(/\.(?:d\.ts|ts|js)$/, "")) + .sort(); +} + +/** + * #7291 closing guard for the phased #7328/#7329/#7330 mcp TypeScript migration -- the loopover-mcp + * twin of loopover-miner's own #7290/#7317 guard in test/unit/miner-typescript-migration-complete.test.ts. + * Every runtime file under packages/loopover-mcp/{bin,lib} must be compiler-owned (.ts source -> emitted + * .js). A lone hand-maintained .js is the drift gap the migration was filed to close. + */ +describe("loopover-mcp TypeScript migration complete (#7291)", () => { + it("has zero hand-maintained .js orphans — every basename has a real .ts source", () => { + for (const dir of dirs) { + const sources = new Set(listBasenames(dir, (name) => name.endsWith(".ts") && !name.endsWith(".d.ts"))); + const scripts = listBasenames(dir, (name) => name.endsWith(".js")); + + const jsWithoutTs = scripts.filter((base) => !sources.has(base)); + + expect(jsWithoutTs, `${dir}/ .js without sibling .ts`).toEqual([]); + expect(scripts).toEqual([...sources].sort()); + } + }); + + // Unlike loopover-miner, packages/loopover-mcp/tsconfig.json sets declaration: false (no pre-existing + // hand-written .d.ts files to replace when the mcp migration started) -- so a .d.ts appearing here at + // all, not just an orphaned one, means either that tsconfig setting or this guard has drifted. + it("emits no .d.ts (declaration: false in packages/loopover-mcp/tsconfig.json)", () => { + for (const dir of dirs) { + const declarations = readdirSync(join(mcpRoot, dir)).filter((name) => name.endsWith(".d.ts")); + expect(declarations, `${dir}/ unexpected .d.ts`).toEqual([]); + } + }); +}); From d8998e76d227064ab53d16ebdd8d64111b8d7278 Mon Sep 17 00:00:00 2001 From: JSONbored <49853598+JSONbored@users.noreply.github.com> Date: Tue, 21 Jul 2026 01:28:00 -0700 Subject: [PATCH 2/2] fix(miner): canonicalize the cross-repo-evaluation scratch workspace path defaultPrepareExecutionWorkspace built its scratch directory straight from mkdtempSync, but coding-task-spec.ts's writeAcceptanceCriteriaFile separately realpath's the working directory before writing into it (a deliberate containment-check canonicalization, not something to remove). On macOS, os.tmpdir() resolves under a symlink (/var/folders/... -> /private/var/folders/...), so the two disagreed on which string names the same directory: a plain acceptanceCriteriaPath.startsWith(workingDirectory) check failed even though the file genuinely was inside the working directory. Resolving once at the source, right after mkdtempSync, keeps every downstream path in the same canonical form with no other changes needed, and is a no-op on Linux CI runners where /tmp isn't itself a symlink. Discovered while validating the build-drift check against #7668's own newly-merged full-execution mode. --- .../lib/cross-repo-evaluation.d.ts | 10 +++++++++- .../loopover-miner/lib/cross-repo-evaluation.js | 16 ++++++++++++---- .../loopover-miner/lib/cross-repo-evaluation.ts | 14 +++++++++++--- test/unit/miner-cross-repo-evaluation.test.ts | 15 ++++++++++++++- 4 files changed, 46 insertions(+), 9 deletions(-) diff --git a/packages/loopover-miner/lib/cross-repo-evaluation.d.ts b/packages/loopover-miner/lib/cross-repo-evaluation.d.ts index 7e843e635a..a074033adf 100644 --- a/packages/loopover-miner/lib/cross-repo-evaluation.d.ts +++ b/packages/loopover-miner/lib/cross-repo-evaluation.d.ts @@ -161,7 +161,15 @@ export type EvaluateRepoExecutionOptions = EvaluateRepoReadinessOptions & { commandTimeoutMs?: number; }; /** Copy the benchmark clone into a discardable temp tree — the agent and the repo's test suite only ever touch - * the copy, so the clone stays pristine and cleanup is a single recursive remove. */ + * the copy, so the clone stays pristine and cleanup is a single recursive remove. realpathSync's the fresh + * mkdtemp directory immediately: on macOS, os.tmpdir() resolves under a symlink (/var/folders/... -> + * /private/var/folders/...), so without this, the raw mkdtempSync path and coding-task-spec.ts's own + * realpathSync(workingDirectory) (a deliberate containment-check canonicalization in writeAcceptanceCriteriaFile, + * not something to remove) disagree on which string names the same directory -- acceptanceCriteriaPath then + * fails a plain acceptanceCriteriaPath.startsWith(workingDirectory) check even though the file genuinely is + * inside the working directory. Resolving once here, at the source, keeps every downstream path (workspace.path, + * task.workingDirectory, the acceptance-criteria path) in the same canonical form with no further changes + * needed. A no-op on Linux CI runners, where /tmp is not itself a symlink. */ export declare function defaultPrepareExecutionWorkspace(repoPath: string): CrossRepoExecutionWorkspace; /** Command runner for the stack's inferred build/test commands. detectRepoStack only ever emits simple * `tool subcommand` forms ("npm test", "cargo build", "npm run build"), so the command is tokenized on diff --git a/packages/loopover-miner/lib/cross-repo-evaluation.js b/packages/loopover-miner/lib/cross-repo-evaluation.js index 0327062a89..b7acd4bb75 100644 --- a/packages/loopover-miner/lib/cross-repo-evaluation.js +++ b/packages/loopover-miner/lib/cross-repo-evaluation.js @@ -4,7 +4,7 @@ // resolveMinerGoalSpec, buildCodingTaskSpec) and failures are categorized as stack-detection gaps, execution // readiness gaps, leaked loopover assumptions in agent instructions, clone/setup problems, or other. import { spawn as nodeSpawn } from "node:child_process"; -import { cpSync, existsSync, mkdtempSync, rmSync } from "node:fs"; +import { cpSync, existsSync, mkdtempSync, realpathSync, rmSync } from "node:fs"; import { tmpdir } from "node:os"; import { join } from "node:path"; // Already a transitive dependency via coding-task-spec.js's own engine imports -- this adds no load weight. @@ -377,9 +377,17 @@ export const DEFAULT_CROSS_REPO_EXECUTION_MAX_TURNS = 24; * benchmark repos, small enough that a hung suite cannot wedge the whole run. */ export const DEFAULT_CROSS_REPO_EXECUTION_COMMAND_TIMEOUT_MS = 600_000; /** Copy the benchmark clone into a discardable temp tree — the agent and the repo's test suite only ever touch - * the copy, so the clone stays pristine and cleanup is a single recursive remove. */ + * the copy, so the clone stays pristine and cleanup is a single recursive remove. realpathSync's the fresh + * mkdtemp directory immediately: on macOS, os.tmpdir() resolves under a symlink (/var/folders/... -> + * /private/var/folders/...), so without this, the raw mkdtempSync path and coding-task-spec.ts's own + * realpathSync(workingDirectory) (a deliberate containment-check canonicalization in writeAcceptanceCriteriaFile, + * not something to remove) disagree on which string names the same directory -- acceptanceCriteriaPath then + * fails a plain acceptanceCriteriaPath.startsWith(workingDirectory) check even though the file genuinely is + * inside the working directory. Resolving once here, at the source, keeps every downstream path (workspace.path, + * task.workingDirectory, the acceptance-criteria path) in the same canonical form with no further changes + * needed. A no-op on Linux CI runners, where /tmp is not itself a symlink. */ export function defaultPrepareExecutionWorkspace(repoPath) { - const scratchRoot = mkdtempSync(join(tmpdir(), "loopover-cross-repo-exec-")); + const scratchRoot = realpathSync(mkdtempSync(join(tmpdir(), "loopover-cross-repo-exec-"))); const path = join(scratchRoot, "repo"); cpSync(repoPath, path, { recursive: true }); return { @@ -558,4 +566,4 @@ export async function runCrossRepoFullExecution(parsed, options = {}) { } return results; } -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cross-repo-evaluation.js","sourceRoot":"","sources":["cross-repo-evaluation.ts"],"names":[],"mappings":"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"} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cross-repo-evaluation.js","sourceRoot":"","sources":["cross-repo-evaluation.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/loopover-miner/lib/cross-repo-evaluation.ts b/packages/loopover-miner/lib/cross-repo-evaluation.ts index 61fdf68c6d..2e4512c915 100644 --- a/packages/loopover-miner/lib/cross-repo-evaluation.ts +++ b/packages/loopover-miner/lib/cross-repo-evaluation.ts @@ -5,7 +5,7 @@ // readiness gaps, leaked loopover assumptions in agent instructions, clone/setup problems, or other. import { spawn as nodeSpawn } from "node:child_process"; -import { cpSync, existsSync, mkdtempSync, rmSync } from "node:fs"; +import { cpSync, existsSync, mkdtempSync, realpathSync, rmSync } from "node:fs"; import { tmpdir } from "node:os"; import { join } from "node:path"; // Already a transitive dependency via coding-task-spec.js's own engine imports -- this adds no load weight. @@ -553,9 +553,17 @@ export type EvaluateRepoExecutionOptions = EvaluateRepoReadinessOptions & { }; /** Copy the benchmark clone into a discardable temp tree — the agent and the repo's test suite only ever touch - * the copy, so the clone stays pristine and cleanup is a single recursive remove. */ + * the copy, so the clone stays pristine and cleanup is a single recursive remove. realpathSync's the fresh + * mkdtemp directory immediately: on macOS, os.tmpdir() resolves under a symlink (/var/folders/... -> + * /private/var/folders/...), so without this, the raw mkdtempSync path and coding-task-spec.ts's own + * realpathSync(workingDirectory) (a deliberate containment-check canonicalization in writeAcceptanceCriteriaFile, + * not something to remove) disagree on which string names the same directory -- acceptanceCriteriaPath then + * fails a plain acceptanceCriteriaPath.startsWith(workingDirectory) check even though the file genuinely is + * inside the working directory. Resolving once here, at the source, keeps every downstream path (workspace.path, + * task.workingDirectory, the acceptance-criteria path) in the same canonical form with no further changes + * needed. A no-op on Linux CI runners, where /tmp is not itself a symlink. */ export function defaultPrepareExecutionWorkspace(repoPath: string): CrossRepoExecutionWorkspace { - const scratchRoot = mkdtempSync(join(tmpdir(), "loopover-cross-repo-exec-")); + const scratchRoot = realpathSync(mkdtempSync(join(tmpdir(), "loopover-cross-repo-exec-"))); const path = join(scratchRoot, "repo"); cpSync(repoPath, path, { recursive: true }); return { diff --git a/test/unit/miner-cross-repo-evaluation.test.ts b/test/unit/miner-cross-repo-evaluation.test.ts index 91f1ab8825..e177c70ef6 100644 --- a/test/unit/miner-cross-repo-evaluation.test.ts +++ b/test/unit/miner-cross-repo-evaluation.test.ts @@ -1,4 +1,4 @@ -import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; +import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { afterEach, describe, expect, it, vi } from "vitest"; @@ -916,6 +916,19 @@ describe("cross-repo evaluation harness (#4788)", () => { expect(existsSync(workspace.path)).toBe(false); }); + // REGRESSION: on macOS, os.tmpdir() resolves under a symlink (/var/folders/... -> /private/var/folders/...), + // so a raw mkdtempSync path and coding-task-spec.ts's own realpathSync(workingDirectory) (a deliberate + // containment-check canonicalization in writeAcceptanceCriteriaFile) used to disagree on which string names + // the same directory. That made a plain acceptanceCriteriaPath.startsWith(workingDirectory) check fail even + // though the file genuinely was inside the working directory ("hands the agent a task rooted in a REAL + // discardable scratch copy" below). Asserted directly here, independent of that whole orchestration, so a + // regression is attributable to defaultPrepareExecutionWorkspace itself rather than rediscovered downstream. + it("REGRESSION: workspace.path is already realpath-canonical — no symlink hop for a downstream caller to trip on", () => { + const workspace = defaultPrepareExecutionWorkspace(nodeFixture()); + expect(workspace.path).toBe(realpathSync(workspace.path)); + workspace.cleanup(); + }); + it("createDefaultCrossRepoExecutionRunCommand reports exit codes, output, timeouts, and spawn errors", async () => { // The runner tokenizes on whitespace and execs directly (no shell), so every command here is a plain // `tool arg...` form — the only shape detectRepoStack ever emits.