@tailor-platform/erp-kit 0.0.1 → 0.1.1

package/src/commands/check.ts

@@ -0,0 +1,66 @@
+import { runMdschema } from "../mdschema.js";
+import { ALL_SCHEMAS } from "../schemas.js";
+export interface CheckTarget {
+  glob: string;
+  schemaKey: string;
+}
+
+export function buildCheckTargets(config: {
+  modulesRoot?: string;
+  appRoot?: string;
+}): CheckTarget[] {
+  const targets: CheckTarget[] = [];
+
+  if (config.modulesRoot) {
+    const m = config.modulesRoot;
+    targets.push(
+      { glob: `${m}/[a-zA-Z]*/docs/features/*.md`, schemaKey: "feature" },
+      { glob: `${m}/[a-zA-Z]*/docs/commands/*.md`, schemaKey: "command" },
+      { glob: `${m}/[a-zA-Z]*/docs/models/*.md`, schemaKey: "model" },
+      { glob: `${m}/[a-zA-Z]*/README.md`, schemaKey: "module" },
+    );
+  }
+
+  if (config.appRoot) {
+    const a = config.appRoot;
+    targets.push(
+      { glob: `${a}/[a-zA-Z]*/README.md`, schemaKey: "requirements" },
+      { glob: `${a}/[a-zA-Z]*/docs/actors/*.md`, schemaKey: "actors" },
+      { glob: `${a}/[a-zA-Z]*/docs/business-flow/*/README.md`, schemaKey: "business-flow" },
+      { glob: `${a}/[a-zA-Z]*/docs/business-flow/*/story/*.md`, schemaKey: "story" },
+      { glob: `${a}/[a-zA-Z]*/docs/screen/*.md`, schemaKey: "screen" },
+      { glob: `${a}/[a-zA-Z]*/docs/resolver/*.md`, schemaKey: "resolver" },
+    );
+  }
+
+  return targets;
+}
+
+export async function runCheck(
+  config: { modulesRoot?: string; appRoot?: string },
+  cwd: string,
+): Promise<number> {
+  const targets = buildCheckTargets(config);
+
+  const results = await Promise.all(
+    targets.map(async (target) => {
+      const schemaPath = ALL_SCHEMAS[target.schemaKey];
+      if (!schemaPath) {
+        console.error(`Unknown schema key: ${target.schemaKey}`);
+        return 2;
+      }
+      const { exitCode, stdout, stderr } = await runMdschema(
+        ["check", target.glob, "--schema", schemaPath],
+        cwd,
+      );
+
+      if (stdout.trim()) console.log(stdout);
+      if (stderr.trim()) console.error(stderr);
+
+      return exitCode;
+    }),
+  );
+
+  if (results.includes(2)) return 2;
+  return results.some((code) => code !== 0) ? 1 : 0;
+}

package/src/commands/init.test.ts

@@ -0,0 +1,88 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { runInit } from "./init.js";
+
+describe("runInit", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "init-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("copies framework skills to .agents/skills/", () => {
+    runInit(tmpDir, false);
+    const skillPath = path.join(tmpDir, ".agents", "skills", "1-module-docs", "SKILL.md");
+    expect(fs.existsSync(skillPath)).toBe(true);
+  });
+
+  it("copies skill references/ directories", () => {
+    runInit(tmpDir, false);
+    const refPath = path.join(
+      tmpDir,
+      ".agents",
+      "skills",
+      "4-module-tdd-implementation",
+      "references",
+      "models.md",
+    );
+    expect(fs.existsSync(refPath)).toBe(true);
+
+    const content = fs.readFileSync(refPath, "utf-8");
+    expect(content).toContain("# Database Models");
+  });
+
+  it("does not overwrite project-specific skills", () => {
+    const customSkillDir = path.join(tmpDir, ".agents", "skills", "my-custom-skill");
+    fs.mkdirSync(customSkillDir, { recursive: true });
+    fs.writeFileSync(path.join(customSkillDir, "SKILL.md"), "# Custom");
+    runInit(tmpDir, false);
+    const content = fs.readFileSync(path.join(customSkillDir, "SKILL.md"), "utf-8");
+    expect(content).toBe("# Custom");
+  });
+
+  it("does not overwrite existing framework skills", () => {
+    const skillDir = path.join(tmpDir, ".agents", "skills", "1-module-docs");
+    fs.mkdirSync(skillDir, { recursive: true });
+    fs.writeFileSync(path.join(skillDir, "SKILL.md"), "# Customized");
+    runInit(tmpDir, false);
+    const content = fs.readFileSync(path.join(skillDir, "SKILL.md"), "utf-8");
+    expect(content).toBe("# Customized");
+  });
+
+  it("overwrites existing framework skills with --force", () => {
+    const skillDir = path.join(tmpDir, ".agents", "skills", "1-module-docs");
+    fs.mkdirSync(skillDir, { recursive: true });
+    fs.writeFileSync(path.join(skillDir, "SKILL.md"), "# Customized");
+    runInit(tmpDir, true);
+    const content = fs.readFileSync(path.join(skillDir, "SKILL.md"), "utf-8");
+    expect(content).not.toBe("# Customized");
+  });
+
+  it("creates .claude/skills symlink to .agents/skills", () => {
+    runInit(tmpDir, false);
+    const claudeSkills = path.join(tmpDir, ".claude", "skills");
+    expect(fs.lstatSync(claudeSkills).isSymbolicLink()).toBe(true);
+    expect(fs.readlinkSync(claudeSkills)).toBe(path.join("..", ".agents", "skills"));
+  });
+
+  it("skips symlink when .claude/skills is a real directory", () => {
+    const claudeSkills = path.join(tmpDir, ".claude", "skills");
+    fs.mkdirSync(claudeSkills, { recursive: true });
+    runInit(tmpDir, false);
+    expect(fs.lstatSync(claudeSkills).isSymbolicLink()).toBe(false);
+  });
+
+  it("relinks symlink with --force when target differs", () => {
+    const claudeSkills = path.join(tmpDir, ".claude", "skills");
+    fs.mkdirSync(path.dirname(claudeSkills), { recursive: true });
+    fs.symlinkSync("../old-target", claudeSkills);
+    runInit(tmpDir, true);
+    expect(fs.readlinkSync(claudeSkills)).toBe(path.join("..", ".agents", "skills"));
+  });
+});

package/src/commands/init.ts

@@ -0,0 +1,120 @@
+import fs from "node:fs";
+import path from "node:path";
+import chalk from "chalk";
+import { PACKAGE_ROOT } from "../util.js";
+
+const SKILLS_SRC = path.join(PACKAGE_ROOT, "skills");
+
+const FRAMEWORK_SKILLS = [
+  "1-module-docs",
+  "2-module-feature-breakdown",
+  "3-module-doc-review",
+  "4-module-tdd-implementation",
+  "5-module-implementation-review",
+  "app-compose-1-requirement-analysis",
+  "app-compose-2-requirements-breakdown",
+  "app-compose-3-doc-review",
+  "app-compose-4-design-mock",
+  "app-compose-5-design-mock-review",
+  "app-compose-6-implementation-spec",
+  "mock-scenario",
+];
+
+function copyDirectoryRecursive(
+  srcDir: string,
+  destDir: string,
+  force: boolean,
+): { copied: number; skipped: number } {
+  let copied = 0;
+  let skipped = 0;
+
+  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+
+    if (entry.isDirectory()) {
+      const sub = copyDirectoryRecursive(srcPath, destPath, force);
+      copied += sub.copied;
+      skipped += sub.skipped;
+    } else {
+      if (!force && fs.existsSync(destPath)) {
+        skipped++;
+        continue;
+      }
+      fs.mkdirSync(destDir, { recursive: true });
+      fs.copyFileSync(srcPath, destPath);
+      copied++;
+    }
+  }
+
+  return { copied, skipped };
+}
+
+export function runInit(cwd: string, force: boolean): number {
+  console.log(chalk.bold("erp-kit init\n"));
+
+  // --- Skills ---
+  const skillsDest = path.join(cwd, ".agents", "skills");
+  let copiedCount = 0;
+  let skippedCount = 0;
+  for (const skill of FRAMEWORK_SKILLS) {
+    const srcSkillDir = path.join(SKILLS_SRC, skill);
+    if (!fs.existsSync(srcSkillDir)) continue;
+
+    const destDir = path.join(skillsDest, skill);
+    const result = copyDirectoryRecursive(srcSkillDir, destDir, force);
+    copiedCount += result.copied;
+
+    if (result.skipped > 0) {
+      console.log(chalk.yellow(`  Skipped ${skill}/ (${result.skipped} existing files)`));
+      skippedCount += result.skipped;
+    }
+  }
+  console.log(chalk.green(`  Copied ${copiedCount} skill files to .agents/skills/`));
+  if (skippedCount > 0) {
+    console.log(
+      chalk.yellow(`  Skipped ${skippedCount} existing files (use --force to overwrite)`),
+    );
+  }
+
+  // --- Claude Code symlink ---
+  const claudeSkills = path.join(cwd, ".claude", "skills");
+  const relTarget = path.relative(path.dirname(claudeSkills), skillsDest);
+
+  // lstatSync doesn't follow symlinks, so dangling symlinks are detected
+  const claudeSkillsExists = (() => {
+    try {
+      fs.lstatSync(claudeSkills);
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+
+  if (claudeSkillsExists) {
+    const stat = fs.lstatSync(claudeSkills);
+    if (stat.isSymbolicLink()) {
+      const current = fs.readlinkSync(claudeSkills);
+      if (current === relTarget) {
+        console.log(chalk.green("  .claude/skills -> .agents/skills/ (already linked)"));
+      } else if (force) {
+        fs.unlinkSync(claudeSkills);
+        fs.symlinkSync(relTarget, claudeSkills);
+        console.log(chalk.green("  .claude/skills -> .agents/skills/ (relinked)"));
+      } else {
+        console.log(
+          chalk.yellow(`  Skipped .claude/skills (symlink exists -> ${current}, use --force)`),
+        );
+      }
+    } else {
+      console.log(chalk.yellow("  Skipped .claude/skills (directory exists, not a symlink)"));
+    }
+  } else {
+    fs.mkdirSync(path.dirname(claudeSkills), { recursive: true });
+    fs.symlinkSync(relTarget, claudeSkills);
+    console.log(chalk.green("  .claude/skills -> .agents/skills/ (linked)"));
+  }
+
+  console.log(chalk.bold.green("\nDone! Run `erp-kit check` to validate your docs."));
+  return 0;
+}

package/src/commands/mock/index.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { defineCommand, arg } from "politty";
+import { runMockStart } from "./start.js";
+import { runMockValidate } from "./validate.js";
+
+const startCommand = defineCommand({
+  name: "start",
+  description: "Start mock API servers with reverse proxy",
+  args: z.object({
+    mocksRoot: arg(z.string().default("./mocks"), {
+      description: "Path to mocks directory",
+    }),
+    port: arg(z.coerce.number().default(3000), {
+      alias: "p",
+      description: "Reverse proxy port",
+    }),
+    filter: arg(z.array(z.string()).default([]), {
+      positional: true,
+      description: "Filter by provider or provider/scenario",
+    }),
+  }),
+  run: async (args) => {
+    const exitCode = await runMockStart(args.mocksRoot, args.filter, args.port);
+    process.exit(exitCode);
+  },
+});
+
+const validateCommand = defineCommand({
+  name: "validate",
+  description: "Validate mock scenario configs",
+  args: z.object({
+    mocksRoot: arg(z.string().default("./mocks"), {
+      description: "Path to mocks directory",
+    }),
+    paths: arg(z.array(z.string()).default([]), {
+      positional: true,
+      description: "Specific scenario paths to validate",
+    }),
+  }),
+  run: async (args) => {
+    const exitCode = await runMockValidate(args.mocksRoot, args.paths);
+    process.exit(exitCode);
+  },
+});
+
+export const mockCommand = defineCommand({
+  name: "mock",
+  description: "Mock API server management",
+  subCommands: {
+    start: startCommand,
+    validate: validateCommand,
+  },
+});

package/src/commands/mock/start.ts

@@ -0,0 +1,179 @@
+import { createServer, request as httpRequest } from "node:http";
+import { createServer as createNetServer } from "node:net";
+import { existsSync, readdirSync } from "node:fs";
+import { resolve, relative, join } from "node:path";
+import { createMockServer, type MockServer } from "../../mockServer.js";
+
+interface MockEntry {
+  provider: string;
+  scenario: string;
+  mockPath: string;
+}
+
+interface RunningMock {
+  server: MockServer;
+  route: string;
+  provider: string;
+  scenario: string;
+}
+
+function readdirSafe(dir: string): string[] {
+  try {
+    return readdirSync(dir, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name);
+  } catch {
+    return [];
+  }
+}
+
+function discoverMocks(mocksDir: string, filters: string[]): MockEntry[] {
+  const mocks: MockEntry[] = [];
+
+  for (const provider of readdirSafe(mocksDir)) {
+    const providerDir = join(mocksDir, provider);
+    for (const scenario of readdirSafe(providerDir)) {
+      const mockPath = join(providerDir, scenario, "mock.json");
+      if (!existsSync(mockPath)) continue;
+      mocks.push({ provider, scenario, mockPath });
+    }
+  }
+
+  if (filters.length === 0) return mocks;
+
+  return mocks.filter(({ provider, scenario }) =>
+    filters.some((f) => f === provider || f === `${provider}/${scenario}`),
+  );
+}
+
+// Mockoon doesn't expose the actual listening port, so we can't use port 0 with readback.
+// This has a minor TOCTOU window between closing this server and Mockoon binding.
+function findFreePort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const srv = createNetServer();
+    srv.listen(0, "127.0.0.1", () => {
+      const addr = srv.address();
+      const port = typeof addr === "object" && addr ? addr.port : 0;
+      srv.close(() => resolve(port));
+    });
+    srv.on("error", reject);
+  });
+}
+
+async function startMock(mock: MockEntry): Promise<RunningMock> {
+  const port = await findFreePort();
+  const server = await createMockServer(mock.mockPath, port);
+  const route = `/${mock.provider}/${mock.scenario}`;
+  return { server, route, provider: mock.provider, scenario: mock.scenario };
+}
+
+function createProxy(routeTable: Map<string, RunningMock>) {
+  return createServer((req, res) => {
+    const match = req.url?.match(/^\/([^/?]+)\/([^/?]+)(\/[^?]*)?(\?.*)?$/);
+    if (!match) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not found. Use /{provider}/{scenario}/..." }));
+      return;
+    }
+
+    const [, provider, scenario] = match;
+    const key = `/${provider}/${scenario}`;
+    const target = routeTable.get(key);
+
+    if (!target) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          error: `Unknown route: ${key}`,
+          available: [...routeTable.keys()],
+        }),
+      );
+      return;
+    }
+
+    // Strip the /{provider}/{scenario} prefix, keep the rest including query string
+    const downstream = (req.url ?? "/").slice(key.length) || "/";
+
+    const proxyReq = httpRequest(
+      {
+        hostname: "127.0.0.1",
+        port: target.server.port,
+        path: downstream,
+        method: req.method,
+        headers: { ...req.headers, host: `127.0.0.1:${target.server.port}` },
+      },
+      (proxyRes) => {
+        res.writeHead(proxyRes.statusCode ?? 502, proxyRes.headers);
+        proxyRes.pipe(res);
+      },
+    );
+
+    proxyReq.on("error", (err) => {
+      if (!res.headersSent) {
+        res.writeHead(502, { "Content-Type": "application/json" });
+      }
+      res.end(JSON.stringify({ error: "Bad gateway", detail: err.message }));
+    });
+
+    req.pipe(proxyReq);
+  });
+}
+
+export async function runMockStart(
+  mocksRoot: string,
+  filters: string[],
+  port: number,
+): Promise<number> {
+  const mocksDir = resolve(mocksRoot);
+  const mocks = discoverMocks(mocksDir, filters);
+
+  if (mocks.length === 0) {
+    console.error("No matching mocks found.");
+    if (filters.length > 0) {
+      console.error(`Filters: ${filters.join(", ")}`);
+      console.error(`Available mocks are under: ${relative(process.cwd(), mocksDir)}/`);
+    }
+    return 1;
+  }
+
+  console.log(`Starting ${mocks.length} mock(s)...\n`);
+
+  const running: RunningMock[] = [];
+  for (const mock of mocks) {
+    const info = await startMock(mock);
+    running.push(info);
+  }
+
+  const routeTable = new Map<string, RunningMock>();
+  for (const r of running) {
+    routeTable.set(r.route, r);
+  }
+
+  console.log("Route table:");
+  console.log("\u2500".repeat(50));
+  for (const [route, { server }] of routeTable) {
+    console.log(`  ${route}  \u2192  127.0.0.1:${server.port}`);
+  }
+  console.log("\u2500".repeat(50));
+
+  const proxy = createProxy(routeTable);
+  proxy.listen(port, () => {
+    console.log(`\nReverse proxy listening on http://localhost:${port}`);
+    console.log("Press Ctrl+C to stop all mocks.\n");
+  });
+
+  function shutdown() {
+    console.log("\nShutting down...");
+    proxy.close();
+    for (const { server } of running) {
+      void server.stop();
+    }
+    process.exit(0);
+  }
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+
+  // Block until signal handler calls process.exit
+  return new Promise<number>(() => void 0);
+}

package/src/commands/mock/validate.test.ts

@@ -0,0 +1,185 @@
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { runMockValidate } from "./validate.js";
+
+let tempDir: string;
+
+beforeEach(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), "mock-validate-"));
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  vi.spyOn(console, "log").mockImplementation(() => {});
+});
+
+afterEach(async () => {
+  vi.restoreAllMocks();
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+function minimalMockJson() {
+  return {
+    uuid: "f7a1b2c3-d4e5-4f6a-8b7c-9d0e1f2a3b4c",
+    lastMigration: 32,
+    name: "Test API",
+    endpointPrefix: "",
+    port: 3000,
+    hostname: "0.0.0.0",
+    latency: 0,
+    folders: [],
+    rootChildren: [{ type: "route", uuid: "c5d8e2f1-3a4b-4c6d-9e7f-1a2b3c4d5e6f" }],
+    proxyMode: false,
+    proxyHost: "",
+    proxyRemovePrefix: false,
+    tlsOptions: {
+      enabled: false,
+      type: "CERT",
+      pfxPath: "",
+      certPath: "",
+      keyPath: "",
+      caPath: "",
+      passphrase: "",
+    },
+    cors: true,
+    headers: [{ key: "Content-Type", value: "application/json" }],
+    proxyReqHeaders: [],
+    proxyResHeaders: [],
+    callbacks: [],
+    data: [
+      {
+        uuid: "a3e72f41-8b56-4c9d-a1e7-2f4b8c56d9e3",
+        id: "items",
+        name: "Items",
+        documentation: "",
+        value: "[]",
+      },
+    ],
+    routes: [
+      {
+        uuid: "c5d8e2f1-3a4b-4c6d-9e7f-1a2b3c4d5e6f",
+        type: "crud",
+        documentation: "CRUD items",
+        method: "",
+        endpoint: "items",
+        responseMode: null,
+        streamingMode: null,
+        streamingInterval: 0,
+        responses: [
+          {
+            uuid: "d6e9f3a2-4b5c-4d7e-8f1a-2b3c4d5e6f7a",
+            label: "CRUD Items",
+            statusCode: 200,
+            latency: 0,
+            headers: [{ key: "Content-Type", value: "application/json" }],
+            body: "",
+            bodyType: "DATABUCKET",
+            databucketID: "items",
+            filePath: "",
+            sendFileAsBody: false,
+            rules: [],
+            rulesOperator: "OR",
+            disableTemplating: false,
+            fallbackTo404: false,
+            default: true,
+            crudKey: "id",
+            callbacks: [],
+          },
+        ],
+      },
+    ],
+  };
+}
+
+async function createScenario(
+  provider: string,
+  scenario: string,
+  mockData?: object,
+  includeReadme = true,
+) {
+  const scenarioDir = join(tempDir, provider, scenario);
+  await mkdir(scenarioDir, { recursive: true });
+  if (mockData) {
+    await writeFile(join(scenarioDir, "mock.json"), JSON.stringify(mockData));
+  }
+  if (includeReadme) {
+    await writeFile(join(scenarioDir, "README.md"), "# Test");
+  }
+}
+
+describe("runMockValidate", () => {
+  it("returns 0 for a valid scenario", async () => {
+    await createScenario("test-provider", "test-scenario", minimalMockJson());
+    const exitCode = await runMockValidate(tempDir, []);
+    expect(exitCode).toBe(0);
+  });
+
+  it("returns 1 when no scenarios found", async () => {
+    const exitCode = await runMockValidate(tempDir, []);
+    expect(exitCode).toBe(1);
+  });
+
+  it("returns 1 when mock.json is missing", async () => {
+    await createScenario("test-provider", "test-scenario", undefined, true);
+    const exitCode = await runMockValidate(tempDir, []);
+    expect(exitCode).toBe(1);
+  });
+
+  it("returns 1 when README.md is missing", async () => {
+    await createScenario("test-provider", "test-scenario", minimalMockJson(), false);
+    const exitCode = await runMockValidate(tempDir, []);
+    expect(exitCode).toBe(1);
+  });
+
+  it("returns 1 for invalid JSON", async () => {
+    const scenarioDir = join(tempDir, "test-provider", "test-scenario");
+    await mkdir(scenarioDir, { recursive: true });
+    await writeFile(join(scenarioDir, "mock.json"), "not json");
+    await writeFile(join(scenarioDir, "README.md"), "# Test");
+    const exitCode = await runMockValidate(tempDir, []);
+    expect(exitCode).toBe(1);
+  });
+
+  it("detects missing Content-Type header", async () => {
+    const data = minimalMockJson();
+    data.routes[0].responses[0].headers = [];
+    await createScenario("test-provider", "test-scenario", data);
+    const exitCode = await runMockValidate(tempDir, []);
+    expect(exitCode).toBe(1);
+  });
+
+  it("detects empty response label", async () => {
+    const data = minimalMockJson();
+    data.routes[0].responses[0].label = "";
+    await createScenario("test-provider", "test-scenario", data);
+    const exitCode = await runMockValidate(tempDir, []);
+    expect(exitCode).toBe(1);
+  });
+
+  it("detects broken databucket reference", async () => {
+    const data = minimalMockJson();
+    data.routes[0].responses[0].databucketID = "nonexistent";
+    await createScenario("test-provider", "test-scenario", data);
+    const exitCode = await runMockValidate(tempDir, []);
+    expect(exitCode).toBe(1);
+  });
+
+  it("validates specific paths when provided", async () => {
+    await createScenario("provider-a", "scenario-a", minimalMockJson());
+    await createScenario("provider-b", "scenario-b", minimalMockJson());
+
+    const exitCode = await runMockValidate(tempDir, [join(tempDir, "provider-a", "scenario-a")]);
+    expect(exitCode).toBe(0);
+  });
+
+  it("can be called multiple times without state leaking", async () => {
+    // First call: failing scenario
+    await createScenario("bad", "scenario", undefined, true);
+    const first = await runMockValidate(tempDir, [join(tempDir, "bad", "scenario")]);
+    expect(first).toBe(1);
+
+    // Second call: valid scenario — failures counter must be reset
+    await createScenario("good", "scenario", minimalMockJson());
+    const second = await runMockValidate(tempDir, [join(tempDir, "good", "scenario")]);
+    expect(second).toBe(0);
+  });
+});