claude-dev-env 8.4.2 → 8.5.0

package/scripts/audit-hooks.mjs

@@ -1,452 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import path from "node:path";
-
-import { KNOWN_GIT_HOOK_NAMES } from "../bin/git_hooks_installer.mjs";
-
-const dispatcherSpecs = Object.freeze([
-  ["script:blocking/pre_tool_use_dispatcher.py", "hooks_constants/pre_tool_use_dispatcher_constants.py", "ALL_HOSTED_HOOK_ENTRIES"],
-  ["script:blocking/bash_pre_tool_use_dispatcher.py", "hooks_constants/bash_pre_tool_use_dispatcher_constants.py", "ALL_BASH_HOSTED_HOOK_ENTRIES"],
-  ["script:validation/post_tool_use_dispatcher.py", "hooks_constants/post_tool_use_dispatcher_constants.py", "ALL_POST_HOSTED_HOOK_ENTRIES"],
-  ["script:blocking/bash_post_call_dispatcher.py", "hooks_constants/bash_post_call_dispatcher_constants.py", "ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES"],
-]);
-const lifecycleNames = new Set([
-  "delete",
-  "keep_boundary_check",
-  "keep_nonblocking_automation",
-  "move_to_ci",
-  "move_to_explicit_command",
-  "move_to_linter",
-]);
-const nonblockingLifecycle = "keep_nonblocking_automation";
-const blockingGitEvents = new Set(["pre-commit", "pre-push"]);
-
-function normalizeMatcher(rawMatcher) {
-  return typeof rawMatcher === "string" && rawMatcher
-    ? rawMatcher.split("|").sort().join("|")
-    : "*";
-}
-
-function targetFromCommand(command, scope, event, ordinal) {
-  const normalized = command.replaceAll("\\", "/");
-  const hookMarker = "/hooks/";
-  if (normalized.includes(hookMarker)) {
-    const relative = normalized.split(hookMarker).at(-1).split(/[\s"']/u, 1)[0];
-    if (relative.endsWith(".py")) return `script:${relative}`;
-  }
-  const importMatch = /\bfrom\s+([A-Za-z_][\w.]*)\s+import\s+main\b/u.exec(command);
-  if (importMatch) return `script:${importMatch[1].replaceAll(".", "/")}.py`;
-  const scriptMatches = [...normalized.matchAll(/(?:^|\s)["']?([^"'/\s]+\.(?:exe|js|mjs|ps1|py))\b/gu)];
-  if (scriptMatches.length) return `external:${scriptMatches.at(-1)[1]}`;
-  return `external:${scope}:${event}:${ordinal}`;
-}
-
-function readDirect(configPath, scope) {
-  const parsed = JSON.parse(readFileSync(configPath, "utf8"));
-  const records = [];
-  for (const [event, groups] of Object.entries(parsed.hooks ?? {})) {
-    for (const group of Array.isArray(groups) ? groups : []) {
-      appendGroupRecords(records, scope, event, group);
-    }
-  }
-  return records;
-}
-
-function appendGroupRecords(records, scope, event, group) {
-  const matcher = normalizeMatcher(group.matcher);
-  for (const hook of Array.isArray(group.hooks) ? group.hooks : []) {
-    if (hook?.type !== "command" || typeof hook.command !== "string") continue;
-    const ordinal = records.length;
-    const target = targetFromCommand(hook.command, scope, event, ordinal);
-    const isDispatcher = dispatcherSpecs.some(([knownTarget]) => knownTarget === target);
-    records.push({
-      event,
-      matcher,
-      ordinal,
-      role: isDispatcher ? "dispatcher" : "hook",
-      scope,
-      target,
-      timeoutSeconds: Number.isInteger(hook.timeout) ? hook.timeout : null,
-    });
-  }
-}
-
-function assignmentBody(source, rosterName) {
-  const rosterOffset = source.lastIndexOf(rosterName);
-  if (rosterOffset < 0) throw new Error(`missing roster ${rosterName}`);
-  const equalsOffset = source.indexOf("=", rosterOffset);
-  const openOffset = source.indexOf("(", equalsOffset);
-  if (equalsOffset < 0 || openOffset < 0) throw new Error(`invalid roster ${rosterName}`);
-  const closeOffset = matchingParenthesis(source, openOffset);
-  return source.slice(openOffset + 1, closeOffset);
-}
-
-function matchingParenthesis(source, openOffset) {
-  let depth = 0;
-  let quote = "";
-  for (let offset = openOffset; offset < source.length; offset += 1) {
-    const character = source[offset];
-    const previous = source[offset - 1];
-    if (quote && character === quote && previous !== "\\") quote = "";
-    else if (!quote && (character === '"' || character === "'")) quote = character;
-    else if (!quote && character === "(") depth += 1;
-    else if (!quote && character === ")") depth -= 1;
-    if (depth === 0) return offset;
-  }
-  throw new Error("unclosed roster");
-}
-
-function topLevelEntries(source) {
-  const entries = [];
-  let depth = 0;
-  let quote = "";
-  let start = 0;
-  for (let offset = 0; offset < source.length; offset += 1) {
-    const character = source[offset];
-    const previous = source[offset - 1];
-    if (quote && character === quote && previous !== "\\") quote = "";
-    else if (!quote && (character === '"' || character === "'")) quote = character;
-    else if (!quote && /[([{]/u.test(character)) depth += 1;
-    else if (!quote && /[\])}]/u.test(character)) depth -= 1;
-    else if (!quote && character === "," && depth === 0) {
-      entries.push(source.slice(start, offset));
-      start = offset + 1;
-    }
-  }
-  entries.push(source.slice(start));
-  return entries.filter((entry) => entry.trim());
-}
-
-function toolMatchers(source) {
-  const matchers = new Map();
-  for (const match of source.matchAll(/\b([A-Z][A-Z0-9_]*_TOOL_NAME)\s*=\s*["']([^"']+)["']/gu)) {
-    matchers.set(match[1], new Set([match[2]]));
-  }
-  const collections = [...source.matchAll(/\b([A-Z][A-Z0-9_]*_TOOL_NAMES)\s*(?::[^=]+)?=\s*frozenset\s*\(/gu)];
-  for (const collection of collections) {
-    const openOffset = source.indexOf("(", collection.index + collection[0].indexOf("frozenset"));
-    const body = source.slice(openOffset + 1, matchingParenthesis(source, openOffset));
-    const names = new Set();
-    for (const token of body.match(/\b[A-Z][A-Z0-9_]+\b/gu) ?? []) {
-      for (const toolName of matchers.get(token) ?? []) names.add(toolName);
-    }
-    matchers.set(collection[1], names);
-  }
-  return matchers;
-}
-
-function rosterEntries(hooksRoot, constantsPath, rosterName) {
-  const source = readFileSync(path.join(hooksRoot, constantsPath), "utf8");
-  const body = assignmentBody(source, rosterName);
-  const matchers = toolMatchers(source);
-  return topLevelEntries(body).map((expression) => {
-    const targetMatch = /["']([^"']+\.py)["']/u.exec(expression);
-    if (!targetMatch) throw new Error(`invalid roster entry ${rosterName}`);
-    const names = new Set();
-    for (const token of expression.match(/\b[A-Z][A-Z0-9_]+\b/gu) ?? []) {
-      for (const toolName of matchers.get(token) ?? []) names.add(toolName);
-    }
-    return {
-      matcher: names.size ? [...names].sort().join("|") : null,
-      target: `script:${targetMatch[1].replaceAll("\\", "/")}`,
-    };
-  });
-}
-
-function expandHosted(directRecords, hooksRoot) {
-  const parents = new Map(
-    directRecords.filter(({ role }) => role === "dispatcher").map((record) => [record.target, record]),
-  );
-  const hosted = [];
-  for (const [dispatcherTarget, constantsPath, rosterName] of dispatcherSpecs) {
-    const parent = parents.get(dispatcherTarget);
-    if (!parent) continue;
-    const entries = rosterEntries(hooksRoot, constantsPath, rosterName);
-    for (const entry of entries) {
-      hosted.push({
-        event: parent.event,
-        matcher: entry.matcher ?? parent.matcher,
-        ordinal: hosted.length,
-        parentTarget: parent.target,
-        role: "hosted",
-        scope: parent.scope,
-        target: entry.target,
-        timeoutSeconds: parent.timeoutSeconds,
-      });
-    }
-  }
-  return hosted;
-}
-
-function logicalRecords(directRecords, hostedRecords) {
-  return [...directRecords.filter(({ role }) => role !== "dispatcher"), ...hostedRecords].sort(recordSort);
-}
-
-function recordSort(left, right) {
-  const leftKey = [left.scope, left.event, left.matcher, left.target, left.role, left.ordinal].join("\0");
-  const rightKey = [right.scope, right.event, right.matcher, right.target, right.role, right.ordinal].join("\0");
-  return leftKey.localeCompare(rightKey);
-}
-
-function duplicateFindings(records, scope) {
-  const counts = new Map();
-  for (const record of records) {
-    const key = [record.event, record.matcher, record.target].join("\0");
-    counts.set(key, (counts.get(key) ?? 0) + 1);
-  }
-  return [...counts.entries()]
-    .filter(([, count]) => count > 1)
-    .map(([key, count]) => ({
-      code: "DUPLICATE_EFFECTIVE_EXECUTION",
-      message: `The same event, matcher, and target run ${count} times.`,
-      scope,
-      severity: "error",
-      target: key.split("\0").at(-1),
-    }));
-}
-
-function missingTargetFindings(records, hooksRoot, scope) {
-  return records
-    .filter(({ target }) => target.startsWith("script:"))
-    .filter(({ target }) => !existsSync(path.join(hooksRoot, target.slice("script:".length))))
-    .map(({ target }) => ({
-      code: "MISSING_HOOK_TARGET",
-      message: "The registered script is missing from the installed hook tree.",
-      scope,
-      severity: "error",
-      target,
-    }));
-}
-
-function missingManagedFindings(expectedRecords, installedRecords, scope) {
-  const installedIdentities = new Set(installedRecords.map(recordIdentity));
-  return expectedRecords
-    .filter((record) => !installedIdentities.has(recordIdentity(record)))
-    .map(({ target }) => ({
-      code: "MISSING_MANAGED_REGISTRATION",
-      message: "The installed configuration is missing a canonical registration.",
-      scope,
-      severity: "error",
-      target,
-    }));
-}
-
-function recordIdentity({ event, matcher, target }) {
-  return [event, matcher, target].join("\0");
-}
-
-function readLifecycle(catalogPath) {
-  if (!catalogPath) return [];
-  const parsed = JSON.parse(readFileSync(catalogPath, "utf8"));
-  return Object.entries(parsed.hooks ?? {}).map(([target, decision]) => {
-    const safeTarget = /^(?:external:[A-Za-z0-9_.:-]+|git:(?:post-commit|pre-commit|pre-push)|script:[A-Za-z0-9_./-]+)$/u;
-    if (!safeTarget.test(target) || !lifecycleNames.has(decision?.lifecycle) || !decision.reason) {
-      throw new Error("invalid lifecycle entry");
-    }
-    return { lifecycle: decision.lifecycle, target };
-  });
-}
-
-function lifecycleFindings(records, lifecycle) {
-  const targets = new Set(records.map(({ target }) => target));
-  const classified = new Set(lifecycle.map(({ target }) => target));
-  const missing = [...targets].filter((target) => !classified.has(target));
-  const stale = [...classified].filter((target) => !targets.has(target));
-  return [
-    ...missing.map((target) => ({
-      code: "UNCLASSIFIED_HOOK",
-      message: "The effective hook has no lifecycle decision.",
-      scope: "catalog",
-      severity: "error",
-      target,
-    })),
-    ...stale.map((target) => ({
-      code: "STALE_LIFECYCLE_ENTRY",
-      message: "The lifecycle target is absent from the canonical graph.",
-      scope: "catalog",
-      severity: "warning",
-      target,
-    })),
-  ];
-}
-
-function nonblockingFindings(records, lifecycle) {
-  const lifecycleByTarget = new Map(
-    lifecycle.map(({ target, lifecycle: lifecycleName }) => [target, lifecycleName]),
-  );
-  const uniqueTargets = [...new Set(records.map(({ target }) => target))];
-  const lifecycleMismatches = uniqueTargets
-    .filter((target) => !target.startsWith("git:") && lifecycleByTarget.has(target))
-    .filter((target) => lifecycleByTarget.get(target) !== nonblockingLifecycle)
-    .map((target) => ({
-      code: "NONBLOCKING_LIFECYCLE_MISMATCH",
-      message: "The registration is not eligible for nonblocking automation.",
-      scope: "catalog",
-      severity: "error",
-      target,
-    }));
-  const blockingGitFindings = records
-    .filter(({ event, scope }) => scope === "git" && blockingGitEvents.has(event))
-    .map(({ target }) => ({
-      code: "NATIVE_GIT_BLOCKING_HOOK",
-      message: "A native Git blocking hook remains active.",
-      scope: "git",
-      severity: "error",
-      target,
-    }));
-  return [...lifecycleMismatches, ...blockingGitFindings];
-}
-
-function registrationEligibility(records, lifecycle, isRequired) {
-  if (!isRequired) {
-    return { status: "not_checked", runtimeProof: "not_assessed" };
-  }
-  const lifecycleByTarget = new Map(
-    lifecycle.map(({ target, lifecycle: lifecycleName }) => [target, lifecycleName]),
-  );
-  const uniqueTargets = [...new Set(records.map(({ target }) => target))];
-  const hasUnclassifiedTarget = uniqueTargets.some((target) => !lifecycleByTarget.has(target));
-  const hasIneligibleTarget = uniqueTargets.some(
-    (target) => lifecycleByTarget.get(target) && lifecycleByTarget.get(target) !== nonblockingLifecycle,
-  );
-  const hasBlockingGitHook = records.some(
-    ({ event, scope }) => scope === "git" && blockingGitEvents.has(event),
-  );
-  const isEligible = !hasUnclassifiedTarget && !hasIneligibleTarget && !hasBlockingGitHook;
-  return {
-    status: isEligible ? "eligible" : "ineligible",
-    runtimeProof: "not_assessed",
-  };
-}
-
-function readInstalled(configPath, hooksRoot, scope) {
-  if (!existsSync(configPath)) return { findings: [], logical: [], records: [] };
-  const records = readDirect(configPath, scope);
-  const hosted = expandHosted(records, hooksRoot);
-  const logical = logicalRecords(records, hosted);
-  return {
-    findings: [
-      ...duplicateFindings(logical, scope),
-      ...missingTargetFindings([...records, ...hosted], hooksRoot, scope),
-    ],
-    logical,
-    records,
-  };
-}
-
-function activeGitHooks(repositoryRoot) {
-  const gitQuery = spawnSync("git", ["rev-parse", "--git-path", "hooks"], {
-    cwd: repositoryRoot,
-    encoding: "utf8",
-    shell: false,
-    timeout: 10_000,
-  });
-  if (gitQuery.status !== 0) return [];
-  const hooksPath = gitQuery.stdout?.trim();
-  if (!hooksPath) return [];
-  const hooksRoot = path.isAbsolute(hooksPath) ? hooksPath : path.resolve(repositoryRoot, hooksPath);
-  return KNOWN_GIT_HOOK_NAMES
-    .filter((name) => existsSync(path.join(hooksRoot, name)))
-    .map((name, ordinal) => ({
-      event: name,
-      matcher: "*",
-      ordinal,
-      role: "native",
-      scope: "git",
-      target: `git:${name}`,
-      timeoutSeconds: null,
-    }));
-}
-
-function knownGitHooks() {
-  return KNOWN_GIT_HOOK_NAMES.map((event, ordinal) => ({
-    event,
-    matcher: "*",
-    ordinal,
-    role: "native",
-    scope: "git",
-    target: `git:${event}`,
-    timeoutSeconds: null,
-  }));
-}
-
-export function auditHooks(options) {
-  const repositoryRoot = path.resolve(options.repositoryRoot);
-  const hooksRoot = path.join(repositoryRoot, "packages", "claude-dev-env", "hooks");
-  const direct = readDirect(path.join(hooksRoot, "hooks.json"), "canonical");
-  const hosted = expandHosted(direct, hooksRoot);
-  const logical = logicalRecords(direct, hosted);
-  const knownGit = knownGitHooks();
-  const lifecycle = readLifecycle(options.catalogPath);
-  const dispatcherCount = direct.filter(({ role }) => role === "dispatcher").length;
-  const installed = options.includeInstalled
-    ? installedAudit(options.homeDirectory ?? homedir(), repositoryRoot, logical)
-    : { claudeCount: 0, codexCount: 0, findings: [], git: [], logical: [], records: [] };
-  const allLogical = [...logical, ...installed.logical, ...installed.git];
-  const isNonblockingRequired = options.requireNonblocking === true;
-  const findings = [
-    ...duplicateFindings(logical, "canonical"),
-    ...(options.catalogPath || isNonblockingRequired ? lifecycleFindings(allLogical, lifecycle) : []),
-    ...(isNonblockingRequired ? nonblockingFindings(allLogical, lifecycle) : []),
-    ...installed.findings,
-  ].sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
-  const targets = new Set(allLogical.map(({ target }) => target));
-  const classified = new Set(lifecycle.map(({ target }) => target));
-  return {
-    directRegistrations: direct.sort(recordSort),
-    findings,
-    hostedRegistrations: hosted.sort(recordSort),
-    installedRegistrations: installed.records.sort(recordSort),
-    installedLogicalRegistrations: installed.logical.sort(recordSort),
-    gitRegistrations: installed.git,
-    knownGitRegistrations: knownGit,
-    lifecycle,
-    logicalRegistrations: logical,
-    schemaVersion: 1,
-    summary: {
-      claudeDirectCount: installed.claudeCount,
-      codexDirectCount: installed.codexCount,
-      directCount: direct.length,
-      dispatcherCount,
-      effectiveCount: hosted.length,
-      findingCount: findings.length,
-      gitHookCount: installed.git.length,
-      knownGitHookCount: knownGit.length,
-      lifecycleCount: lifecycle.length,
-      logicalAssociationCount: logical.length,
-      unclassifiedCount: options.catalogPath || isNonblockingRequired
-        ? [...targets].filter((target) => !classified.has(target)).length
-        : 0,
-      uniqueTargetCount: targets.size,
-    },
-    registrationEligibility: registrationEligibility(allLogical, lifecycle, isNonblockingRequired),
-  };
-}
-
-function installedAudit(homeDirectory, repositoryRoot, canonicalLogical) {
-  const claude = readInstalled(
-    path.join(homeDirectory, ".claude", "settings.json"),
-    path.join(homeDirectory, ".claude", "hooks"),
-    "claude",
-  );
-  const codex = readInstalled(
-    path.join(homeDirectory, ".codex", "hooks.json"),
-    path.join(homeDirectory, ".codex", "hooks"),
-    "codex",
-  );
-  const git = activeGitHooks(repositoryRoot);
-  return {
-    claudeCount: claude.records.length,
-    codexCount: codex.records.length,
-    findings: [
-      ...claude.findings,
-      ...codex.findings,
-      ...missingManagedFindings(canonicalLogical, claude.logical, "claude"),
-      ...missingManagedFindings(canonicalLogical, codex.logical, "codex"),
-    ],
-    git,
-    logical: [...claude.logical, ...codex.logical],
-    records: [...claude.records, ...codex.records],
-  };
-}

package/scripts/tests/test-audit-hooks-cli.mjs

@@ -1,150 +0,0 @@
-import assert from "node:assert/strict";
-import { spawnSync } from "node:child_process";
-import {
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import test from "node:test";
-import { fileURLToPath } from "node:url";
-
-const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const auditCliPath = path.join(packageRoot, "audit-hooks-cli.mjs");
-
-function writeJson(filePath, jsonDocument) {
-  writeFileSync(filePath, JSON.stringify(jsonDocument), "utf8");
-}
-
-function createAuditFixture({
-  canonicalHooks = {},
-  claudeHooks = { hooks: {} },
-  codexHooks = { hooks: {} },
-} = {}) {
-  const fixtureRoot = mkdtempSync(path.join(tmpdir(), "hook-audit-cli-"));
-  const canonicalHooksRoot = path.join(fixtureRoot, "packages", "claude-dev-env", "hooks");
-  const homeDirectory = path.join(fixtureRoot, "home");
-  mkdirSync(canonicalHooksRoot, { recursive: true });
-  mkdirSync(path.join(homeDirectory, ".claude", "hooks"), { recursive: true });
-  mkdirSync(path.join(homeDirectory, ".codex", "hooks"), { recursive: true });
-  writeJson(path.join(canonicalHooksRoot, "hooks.json"), { hooks: canonicalHooks });
-  writeJson(path.join(homeDirectory, ".claude", "settings.json"), claudeHooks);
-  writeJson(path.join(homeDirectory, ".codex", "hooks.json"), codexHooks);
-  return { fixtureRoot, homeDirectory };
-}
-
-function runAuditCli(allArguments) {
-  const childProcess = spawnSync(process.execPath, [auditCliPath, ...allArguments], {
-    cwd: packageRoot,
-    encoding: "utf8",
-    env: { ...process.env, HOME: path.join(tmpdir(), "unused-audit-cli-home") },
-    shell: false,
-  });
-  assert.equal(childProcess.error, undefined);
-  return childProcess;
-}
-
-test("writes a JSON audit report to stdout through the CLI", () => {
-  const fixture = createAuditFixture({
-    canonicalHooks: {
-      PreToolUse: [{
-        matcher: "Write",
-        hooks: [{
-          type: "command",
-          command: "python3 " + "$" + "{CLAUDE_PLUGIN_ROOT}/hooks/blocking/write_existing_file_blocker.py",
-        }],
-      }],
-    },
-  });
-  try {
-    const childProcess = runAuditCli([
-      "--format",
-      "json",
-      "--repository-root",
-      fixture.fixtureRoot,
-    ]);
-
-    assert.equal(childProcess.status, 0);
-    assert.equal(childProcess.stderr, "");
-    const report = JSON.parse(childProcess.stdout);
-    assert.equal(report.summary.directCount, 1);
-    assert.equal(report.registrationEligibility.status, "not_checked");
-  } finally {
-    rmSync(fixture.fixtureRoot, { force: true, recursive: true });
-  }
-});
-
-test("writes the JSON audit report to the requested file through the CLI", () => {
-  const fixture = createAuditFixture();
-  const reportPath = path.join(fixture.fixtureRoot, "audit-report.json");
-  try {
-    const childProcess = runAuditCli([
-      "--format",
-      "json",
-      "--output",
-      reportPath,
-      "--repository-root",
-      fixture.fixtureRoot,
-    ]);
-
-    assert.equal(childProcess.status, 0);
-    assert.equal(childProcess.stdout, "");
-    const report = JSON.parse(readFileSync(reportPath, "utf8"));
-    assert.equal(report.summary.directCount, 0);
-    assert.equal(report.summary.findingCount, 0);
-  } finally {
-    rmSync(fixture.fixtureRoot, { force: true, recursive: true });
-  }
-});
-
-test("returns a strict nonblocking failure through the CLI", () => {
-  const fixture = createAuditFixture({
-    claudeHooks: {
-      hooks: {
-        SessionStart: [{
-          hooks: [{ command: "node cleanup.mjs", type: "command" }],
-        }],
-      },
-    },
-  });
-  const catalogPath = path.join(fixture.fixtureRoot, "lifecycle.json");
-  writeJson(catalogPath, {
-    hooks: {
-      "external:cleanup.mjs": {
-        lifecycle: "delete",
-        reason: "The installed entry is retired.",
-        replacement: null,
-      },
-    },
-  });
-  try {
-    const childProcess = runAuditCli([
-      "--format",
-      "json",
-      "--catalog",
-      catalogPath,
-      "--home",
-      fixture.homeDirectory,
-      "--installed",
-      "--require-nonblocking",
-      "--repository-root",
-      fixture.fixtureRoot,
-    ]);
-
-    assert.equal(childProcess.status, 1);
-    assert.equal(childProcess.stderr, "");
-    const report = JSON.parse(childProcess.stdout);
-    assert.equal(report.registrationEligibility.status, "ineligible");
-    assert.equal(
-      report.findings.some(({ code, target }) =>
-        code === "NONBLOCKING_LIFECYCLE_MISMATCH" && target === "external:cleanup.mjs",
-      ),
-      true,
-    );
-  } finally {
-    rmSync(fixture.fixtureRoot, { force: true, recursive: true });
-  }
-});