jui-tools-mcp-server 2.16.0 → 2.17.0

package/scripts/record-infra-fixtures.sh

@@ -0,0 +1,78 @@
+#!/bin/bash
+# Record what the jsonui-doc infra commands print with --json, as the infra tools' test fixtures
+# (tests/fixtures/infra/*.json). The tools summarise those outputs, so the fixtures are the CLI's contract: when the
+# CLI's JSON changes, record again and the tools' tests say what no longer holds.
+#
+#   scripts/record-infra-fixtures.sh <jsonui-cli checkout>     # e.g. a worktree of integrate/2.3.15
+#
+# Rooms: jsonui-cli's own document_tools/tests/fixtures/infra (aws-three-tier: a model, two load scenarios, a price
+# file; compose-and-cloud: what seed reads), copied to a temp folder; one copy is broken on purpose (a load file that
+# is not JSON, a model file with a schema error) so the error shapes are recorded too. The fetched-price cache is kept
+# out (JUI_VIZ_HOME points nowhere), so the bundled table prices them.
+set -euo pipefail
+CLI_ROOT="$(cd "${1:?usage: $0 <jsonui-cli checkout>}" && pwd)"
+HERE="$(cd "$(dirname "$0")/.." && pwd)"
+OUT="${HERE}/tests/fixtures/infra"
+FIX="${CLI_ROOT}/document_tools/tests/fixtures/infra"
+WORK="$(mktemp -d)"
+trap 'rm -rf "${WORK}"' EXIT
+
+export PYTHONPATH="${CLI_ROOT}/document_tools:${CLI_ROOT}/jui_tools:${CLI_ROOT}/test_tools"
+export JUI_VIZ_HOME=/nonexistent
+doc() { (cd "$1" && shift && python3 -m jsonui_doc_cli.cli "$@") || true; }
+
+cp -R "${FIX}/aws-three-tier" "${WORK}/room"
+cp -R "${FIX}/aws-three-tier" "${WORK}/broken"
+printf '{' > "${WORK}/broken/docs/infra/load/broken.json"
+printf '{"version": 0, "nodes": [{"id": "x", "category": "nope"}]}' > "${WORK}/broken/docs/infra/bad.json"
+mkdir -p "${WORK}/seed/app"
+cat > "${WORK}/seed/docker-compose.yml" <<'EOF'
+services:
+  web:
+    image: example/web
+    depends_on: [db, cache]
+  db:
+    image: postgres:16
+  cache:
+    image: redis:7
+EOF
+cat > "${WORK}/seed/main.tf" <<'EOF'
+provider "aws" { region = "ap-northeast-1" }
+resource "aws_db_instance" "main" { engine = "postgres" }
+resource "aws_lb" "web" { load_balancer_type = "application" }
+resource "aws_s3_bucket" "assets" {}
+resource "aws_glue_job" "etl" {}
+EOF
+printf 'import boto3\nimport stripe\nQUEUE_URL = "SQS_QUEUE_URL"\n' > "${WORK}/seed/app/main.py"
+cat > "${WORK}/room/jui.config.json" <<'EOF'
+{"checks": [{"name": "infra-load", "type": "builtin:infra-load"}, {"name": "infra-code", "type": "builtin:infra-code"}]}
+EOF
+
+mkdir -p "${OUT}" "${WORK}/empty"
+doc "${WORK}/empty" validate infra --json > "${OUT}/validate-infra.unreadable.json"
+doc "${WORK}/empty" validate infra-load --json > "${OUT}/validate-infra-load.unreadable.json"
+doc "${WORK}/room" validate infra --json > "${OUT}/validate-infra.ok.json"
+doc "${WORK}/broken" validate infra --json > "${OUT}/validate-infra.errors.json"
+doc "${WORK}/room" validate infra-load --json > "${OUT}/validate-infra-load.ok.json"
+doc "${WORK}/broken" validate infra-load --json > "${OUT}/validate-infra-load.errors.json"
+doc "${WORK}/room" validate infra-prices --json > "${OUT}/validate-infra-prices.ok.json"
+doc "${WORK}/seed" seed infra -o "${WORK}/seed-out" > /dev/null
+cp "${WORK}/seed-out/draft.json" "${OUT}/seed-infra.draft.json"
+cp "${WORK}/seed-out/seed-report.json" "${OUT}/seed-infra.report.json"
+doc "${WORK}/room" cost infra --json > "${OUT}/cost-infra.month.json"
+doc "${WORK}/room" cost infra --by node --scenario sale --json > "${OUT}/cost-infra.month-by-node.json"
+doc "${WORK}/room" cost infra --date 2026-11-03 --json > "${OUT}/cost-infra.day.json"
+doc "${WORK}/room" cost infra --scenario nope --json > "${OUT}/cost-infra.refused.json"
+doc "${WORK}/room" check infra --json 2>/dev/null > "${OUT}/check-infra.json"
+
+# The temp folder's path is not part of the contract
+for f in "${OUT}"/*.json; do
+  python3 - "$f" "${WORK}" <<'EOF'
+import sys
+p, work = sys.argv[1:]
+s = open(p, encoding="utf-8").read().replace(work, "<ROOT>")
+open(p, "w", encoding="utf-8").write(s)
+EOF
+done
+git -C "${CLI_ROOT}" log -1 --format='%h %s' > "${OUT}/RECORDED_FROM"
+ls -1 "${OUT}"

package/src/index.ts

@@ -59,6 +59,12 @@ import { register as registerVizDoctor } from "./tools/viz/viz_doctor.js";
 import { register as registerVizStart } from "./tools/viz/viz_start.js";
 import { register as registerVizStop } from "./tools/viz/viz_stop.js";
 import { register as registerVizOpen } from "./tools/viz/viz_open.js";
+import { register as registerInfraValidate } from "./tools/infra/infra_validate.js";
+import { register as registerInfraLoadValidate } from "./tools/infra/infra_load_validate.js";
+import { register as registerInfraPricesValidate } from "./tools/infra/infra_prices_validate.js";
+import { register as registerInfraSeed } from "./tools/infra/infra_seed.js";
+import { register as registerInfraCheck } from "./tools/infra/infra_check.js";
+import { register as registerInfraCost } from "./tools/infra/infra_cost.js";
 
 // --- Group F: jsonui-test CLI ---
 import { register as registerTestValidate } from "./tools/test/test_validate.js";
@@ -174,7 +180,17 @@ registerVizStart(server);
 registerVizStop(server);
 registerVizOpen(server);
 
-log(`Registered 51 tools (9 spec + 7 context + 8 jui + 9 doc + 3 api + 10 test + 5 viz)`);
+// Register Group H: the server room's infra (6 tools) — jsonui-doc's validate / seed / check / cost infra, each
+// summarised from its --json (jsonui-cli 2.3.15+). `jui viz cloud-prices fetch` stays with the CLI (it goes to the
+// network and writes the viz home).
+registerInfraValidate(server, config);
+registerInfraLoadValidate(server, config);
+registerInfraPricesValidate(server, config);
+registerInfraSeed(server, config);
+registerInfraCheck(server, config);
+registerInfraCost(server, config);
+
+log(`Registered 57 tools (9 spec + 7 context + 8 jui + 9 doc + 3 api + 10 test + 5 viz + 6 infra)`);
 
 async function main() {
   const transport = new StdioServerTransport();

package/src/tools/infra/infra_check.ts

@@ -0,0 +1,49 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { FIRST, failure, need, runDocJson, text } from "./infra_common.js";
+
+/**
+ * `jsonui-doc check infra -p <project> --json`: the declared infra checks (jui.config.json → checks:
+ * builtin:infra-iac, builtin:infra-code, builtin:infra-load) — the model against the IaC, the code, and the load
+ * definitions. This is the one jsonui-doc command that runs project-declared checks; the infra ones read files only.
+ * Exit 0: clean (warnings alone are 0); 1: a mismatch (a finding of a check declared with gate: true); 2: an
+ * execution error, or no infra check is declared.
+ */
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "infra_check",
+    "Run the project's declared infra checks with `jsonui-doc check infra --json` (jui.config.json → checks: builtin:infra-iac = the model against Terraform/Compose/CloudFormation/k8s/wrangler, builtin:infra-code = against the code's evidence, SDK imports and env names, builtin:infra-load = against the load definitions). Returns each check's status (ok / mismatch / error), counts, the first 20 results that are not ok (target, status, expected, actual, message), warnings, and its report file. Findings are warnings unless the check sets gate: true. Needs jsonui-cli 2.3.15+.",
+    {
+      project_dir: z.string().optional().describe("Project directory with jui.config.json (overrides JUI_PROJECT_DIR env)"),
+    },
+    async ({ project_dir }) => {
+      try {
+        const projectDir = config.resolveProjectDir(project_dir);
+        const { exitCode, data, stderr } = await runDocJson(["check", "infra", "-p", projectDir, "--json"], projectDir, 180_000);
+        need(data, ["ok", "exit", "checks"], "check infra");
+        if (!data.checks.length) {
+          return text({ ok: false, exit: exitCode, checks: [],
+            message: stderr.trim() || "no builtin:infra-* check is declared in jui.config.json → checks",
+            declared: data.declared ?? [] });
+        }
+        return text({
+          ok: data.ok,
+          exit: exitCode,
+          checks: data.checks.map((c: any) => {
+            need(c, ["name", "type", "status"], "check infra check");
+            if (c.status === "error") return { name: c.name, type: c.type, status: "error", error: c.error };
+            need(c, ["summary", "results", "warnings", "report"], "check infra check");
+            return {
+              name: c.name, type: c.type, status: c.status, summary: c.summary,
+              results: c.results.slice(0, FIRST), resultCount: c.results.length,
+              warnings: c.warnings.slice(0, FIRST), report: c.report,
+            };
+          }),
+        });
+      } catch (e: any) {
+        return failure(e);
+      }
+    }
+  );
+}

package/src/tools/infra/infra_common.ts

@@ -0,0 +1,69 @@
+import { runCli } from "../../cli_runner.js";
+
+/**
+ * Shared by the Group H tools: run a `jsonui-doc … --json` infra command and read its one JSON object.
+ *
+ * The tools summarise that object for an agent (counts, the first problems, the totals), so the keys they read are
+ * the CLI's contract. `need` names a key the object lacks instead of summarising nothing — a jsonui-doc older or
+ * newer than these tools says so rather than reading as an empty room. The tests feed the CLI's own recorded output
+ * (tests/fixtures/infra, scripts/record-infra-fixtures.sh).
+ */
+
+export interface JsonRun {
+  exitCode: number;
+  data: any;
+  stderr: string;
+}
+
+export class ContractError extends Error {}
+
+export const FIRST = 20;
+
+export async function runDocJson(args: string[], cwd: string, timeout?: number): Promise<JsonRun> {
+  const result = await runCli("jsonui-doc", args, { cwd, timeout });
+  let data: any;
+  try {
+    data = JSON.parse(result.stdout);
+  } catch {
+    throw new ContractError(
+      `jsonui-doc ${args.slice(0, 2).join(" ")} printed no JSON (exit ${result.exitCode})` +
+        (result.stderr ? `: ${result.stderr.trim().split("\n").slice(-3).join(" / ")}` : "") +
+        " — it needs jsonui-cli 2.3.15 or later for --json here"
+    );
+  }
+  return { exitCode: result.exitCode, data, stderr: result.stderr };
+}
+
+export function need(obj: any, keys: string[], what: string): void {
+  const missing = keys.filter((k) => obj == null || !(k in obj));
+  if (missing.length) {
+    throw new ContractError(
+      `${what}: the JSON has no ${missing.map((k) => `"${k}"`).join(", ")} — a jsonui-doc these tools do not know; ` +
+        "update jsonui-cli or this server"
+    );
+  }
+}
+
+/** A problem list as counts (by severity, by code) and the first FIRST, each as written. */
+export function problems(list: any[], what: string, keep: string[] = ["severity", "code", "file", "path", "message"]) {
+  if (!Array.isArray(list)) throw new ContractError(`${what}: "problems" is not a list`);
+  const bySeverity: Record<string, number> = {};
+  const byCode: Record<string, number> = {};
+  for (const p of list) {
+    need(p, ["severity", "code"], `${what} problem`);
+    bySeverity[p.severity] = (bySeverity[p.severity] ?? 0) + 1;
+    byCode[p.code] = (byCode[p.code] ?? 0) + 1;
+  }
+  const first = list.slice(0, FIRST).map((p) =>
+    Object.fromEntries(keep.filter((k) => p[k] !== undefined && p[k] !== null).map((k) => [k, p[k]]))
+  );
+  return { count: list.length, errors: bySeverity.error ?? 0, warnings: bySeverity.warning ?? 0, byCode, first };
+}
+
+export function text(value: unknown) {
+  return { content: [{ type: "text" as const, text: JSON.stringify(value, null, 2) }] };
+}
+
+export function failure(e: any) {
+  return { content: [{ type: "text" as const, text: `Error: ${e.message}` }] };
+}

package/src/tools/infra/infra_cost.ts

@@ -0,0 +1,122 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { FIRST, failure, need, problems, runDocJson, text } from "./infra_common.js";
+
+/**
+ * `jsonui-doc cost infra <project> --json`: the cost simulator's month (or one day) for a load scenario, the same
+ * simulation and shapes as jui viz's コスト. The month's whole reply (every day's stack) and above all a day's (every
+ * node's 24 hours with each meter's price trace, ~300 KB) are too long for an agent; this keeps what answers "what
+ * does it cost and why": the total, the totals per stack key, the top nodes, what has no price / rule / load, the
+ * hours over capacity, the notes, the load problems and the price-book warnings — and for a day, each top node's
+ * charge by meter with the price layer it came from. Exit 0: simulated; 1: simulated, a load file has an error (left
+ * out); 2: nothing simulated (reason).
+ */
+
+function monthSummary(m: any) {
+  need(m, ["scenario", "month", "usd", "by", "keys", "days", "noPrice", "noRule", "loadUndefined", "overflowHours",
+    "warnings", "warningCount"], "cost infra month");
+  const totals: Record<string, number> = {};
+  for (const d of m.days) {
+    need(d, ["date", "usd", "stack"], "cost infra day of the month");
+    for (const [k, v] of Object.entries(d.stack)) totals[k] = (totals[k] ?? 0) + (v as number);
+  }
+  const label = Object.fromEntries(m.keys.map((k: any) => [k.key, k.label]));
+  return {
+    scenario: m.scenario,
+    month: m.month,
+    usd: m.usd,
+    by: m.by,
+    totals: Object.entries(totals).sort((a, b) => b[1] - a[1])
+      .map(([key, usd]) => ({ key: key === "__others__" ? "others" : key, label: label[key] ?? key, usd })),
+    days: m.days.length,
+    dearestDay: m.days.reduce((a: any, b: any) => (b.usd > a.usd ? b : a), m.days[0])?.date ?? null,
+    noPrice: m.noPrice,
+    noRule: m.noRule,
+    loadUndefined: m.loadUndefined,
+    overflowHours: m.overflowHours,
+    notes: m.warnings.slice(0, FIRST).map((w: any) => (typeof w === "string" ? w : w.message)),
+    noteCount: m.warningCount,
+  };
+}
+
+function daySummary(day: any) {
+  need(day, ["scenario", "date", "usd", "nodes", "others"], "cost infra day");
+  return {
+    scenario: day.scenario,
+    date: day.date,
+    usd: day.usd,
+    nodes: day.nodes.map((n: any) => {
+      need(n, ["node", "usd", "hours"], "cost infra day node");
+      const meters: Record<string, { usd: number; amount: number; unit: string; sku: string; layer: string | null }> = {};
+      let peak = { hour: 0, usd: -1 };
+      n.hours.forEach((h: any, i: number) => {
+        if (h.usd > peak.usd) peak = { hour: day.hours?.[i] ?? i, usd: h.usd };
+        for (const s of h.segments ?? []) {
+          const m = (meters[s.meter] ??= { usd: 0, amount: 0, unit: s.unit, sku: s.sku, layer: s.price?.layer ?? null });
+          m.usd += s.usd ?? 0;
+          m.amount += s.amount ?? 0;
+        }
+      });
+      const overflowHours = n.hours.filter((h: any) => h.load && h.load.overflow > 0).length;
+      return {
+        node: n.node, label: n.label, provider: n.provider, rule: n.rule, note: n.note || undefined, usd: n.usd,
+        peakHour: peak.usd >= 0 ? peak.hour : null, meters, overflowHours: overflowHours || undefined,
+      };
+    }),
+    others: { count: day.others.count, usd: (day.others.usd as number[]).reduce((a, b) => a + b, 0) },
+  };
+}
+
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "infra_cost",
+    "Simulate the server room's cost with `jsonui-doc cost infra --json` (the model, a load scenario under docs/infra/load, prices: the room's own, then fetched, then bundled — USD, on demand). Without date: the month's total, totals by provider (or by node), the top nodes, the dearest day, what has no price / no rule / no load, hours over capacity, notes. With date (YYYY-MM-DD in the scenario's month): that day's top nodes, each with its charge by meter, the price layer, and its peak hour. Also the scenarios there are, the load problems and the price-book warnings (prices.free_dropped: a room's price row dropping a bundled free amount). Needs jsonui-cli 2.3.15+.",
+    {
+      project_dir: z.string().optional().describe("Project directory with jui.config.json (overrides JUI_PROJECT_DIR env)"),
+      scenario: z.string().optional().describe("Load scenario id (default: the first)"),
+      date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("One day of the scenario's month (YYYY-MM-DD)"),
+      by: z.enum(["provider", "node"]).optional().describe("Group the month's totals by provider (default) or node"),
+    },
+    async ({ project_dir, scenario, date, by }) => {
+      try {
+        const projectDir = config.resolveProjectDir(project_dir);
+        const args = ["cost", "infra", projectDir, "--json"];
+        if (scenario) args.push("--scenario", scenario);
+        if (date) args.push("--date", date);
+        if (by) args.push("--by", by);
+        const { exitCode, data } = await runDocJson(args, projectDir, 180_000);
+        need(data, ["ok"], "cost infra");
+        if (!data.ok) {
+          need(data, ["reason", "message"], "cost infra");
+          return text({ ok: false, exit: exitCode, reason: data.reason, message: data.message,
+            ...(data.problems ? { problems: problems(data.problems, "cost infra") } : {}) });
+        }
+        need(data, ["dir", "scenario", "scenarios", "problems", "prices"], "cost infra");
+        need(data.problems, ["count", "errors", "first"], "cost infra problems");
+        need(data.prices, ["warnings", "warningCount"], "cost infra prices");
+        const out: Record<string, unknown> = {
+          ok: exitCode === 0,
+          exit: exitCode,
+          dir: data.dir,
+          scenario: data.scenario,
+          scenarios: data.scenarios,
+          loadProblems: data.problems,
+          priceWarnings: data.prices.warnings,
+          priceWarningCount: data.prices.warningCount,
+        };
+        if (date) {
+          need(data, ["day"], "cost infra");
+          out.day = daySummary(data.day);
+        } else {
+          need(data, ["month", "topNodes"], "cost infra");
+          out.month = monthSummary(data.month);
+          out.topNodes = data.topNodes;
+        }
+        return text(out);
+      } catch (e: any) {
+        return failure(e);
+      }
+    }
+  );
+}

package/src/tools/infra/infra_load_validate.ts

@@ -0,0 +1,46 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { failure, need, problems, runDocJson, text } from "./infra_common.js";
+
+/**
+ * `jsonui-doc validate infra-load <project> --json`: the load scenarios the cost simulator reads (<infra.dir>/load,
+ * or infra.load_dir) against their schema and against the model. Exit 0: no error; 1: errors; 2: the model or the
+ * folder cannot be read (reason).
+ */
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "infra_load_validate",
+    "Validate the server room's load scenarios (docs/infra/load/*.json) with `jsonui-doc validate infra-load --json`. Returns each scenario (id, environment, month, hours, loads, edges) and the problems by severity and code with the first 20 (file, path, code, message, node, hour, quantity). load.overlap means a node has two rows and only one counts. Needs jsonui-cli 2.3.15+.",
+    {
+      project_dir: z.string().optional().describe("Project directory with jui.config.json (overrides JUI_PROJECT_DIR env)"),
+    },
+    async ({ project_dir }) => {
+      try {
+        const projectDir = config.resolveProjectDir(project_dir);
+        const { exitCode, data } = await runDocJson(["validate", "infra-load", projectDir, "--json"], projectDir);
+        need(data, ["ok"], "validate infra-load");
+        if (!data.ok) {
+          need(data, ["reason", "message"], "validate infra-load");
+          return text({ ok: false, exit: exitCode, readable: false, reason: data.reason, message: data.message });
+        }
+        need(data, ["dir", "files", "problems", "scenarios"], "validate infra-load");
+        for (const s of data.scenarios) need(s, ["id", "environment", "month", "hours", "loads", "edges"], "validate infra-load scenario");
+        return text({
+          ok: exitCode === 0,
+          exit: exitCode,
+          readable: true,
+          dir: data.dir,
+          files: data.files,
+          scenarios: data.scenarios.map((s: any) => ({
+            id: s.id, file: s.file, environment: s.environment, month: s.month, hours: s.hours, loads: s.loads, edges: s.edges,
+          })),
+          problems: problems(data.problems, "validate infra-load",
+            ["severity", "code", "file", "path", "message", "node", "hour", "quantity"]),
+        });
+      } catch (e: any) {
+        return failure(e);
+      }
+    }
+  );
+}

package/src/tools/infra/infra_prices_validate.ts

@@ -0,0 +1,41 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { failure, need, problems, runDocJson, text } from "./infra_common.js";
+
+/**
+ * `jsonui-doc validate infra-prices <project> --json`: the room's own price files (<infra.dir>/prices, or
+ * infra.prices_dir). Exit 0: no error; 1: errors; 2: the folder cannot be read (reason).
+ */
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "infra_prices_validate",
+    "Validate the server room's own price files (docs/infra/prices/*.json — only for what the bundled prices lack) with `jsonui-doc validate infra-prices --json`. Returns the files used, how many prices, and the problems by severity and code with the first 20. Needs jsonui-cli 2.3.15+.",
+    {
+      project_dir: z.string().optional().describe("Project directory with jui.config.json (overrides JUI_PROJECT_DIR env)"),
+    },
+    async ({ project_dir }) => {
+      try {
+        const projectDir = config.resolveProjectDir(project_dir);
+        const { exitCode, data } = await runDocJson(["validate", "infra-prices", projectDir, "--json"], projectDir);
+        need(data, ["ok"], "validate infra-prices");
+        if (!data.ok) {
+          need(data, ["reason", "message"], "validate infra-prices");
+          return text({ ok: false, exit: exitCode, readable: false, reason: data.reason, message: data.message });
+        }
+        need(data, ["dir", "files", "problems", "count"], "validate infra-prices");
+        return text({
+          ok: exitCode === 0,
+          exit: exitCode,
+          readable: true,
+          dir: data.dir,
+          files: data.files,
+          count: data.count,
+          problems: problems(data.problems, "validate infra-prices"),
+        });
+      } catch (e: any) {
+        return failure(e);
+      }
+    }
+  );
+}

package/src/tools/infra/infra_seed.ts

@@ -0,0 +1,88 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { ServerConfig } from "../../config.js";
+import { ContractError, FIRST, failure, need, text } from "./infra_common.js";
+import { runCli } from "../../cli_runner.js";
+
+/**
+ * `jsonui-doc seed infra <project> -o <dir>`: a draft model from what the project already says (Compose, Terraform /
+ * OpenTofu, Kubernetes, CloudFormation / SAM / CDK, wrangler, PaaS files, SDK imports and env names; never state,
+ * tfvars or .env values), and its report (what it read, what it could not place). By default the draft is written to
+ * a temp folder and read back — nothing in the project changes; write: true writes <infra.dir>/seed (the draft is a
+ * starting point, never read as the model). Exit 0: drafted; 2: refused (bad config, the draft fails its own check,
+ * or a draft is already there without force).
+ */
+
+function infraDir(projectDir: string): string {
+  try {
+    const cfg = JSON.parse(readFileSync(join(projectDir, "jui.config.json"), "utf-8"));
+    if (typeof cfg?.infra?.dir === "string") return cfg.infra.dir;
+  } catch {
+    // no config, or not JSON: the CLI says so itself
+  }
+  return "docs/infra";
+}
+
+function readJson(path: string, what: string): any {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    throw new ContractError(`seed infra wrote no readable ${what} at ${path}`);
+  }
+}
+
+export function summarize(draft: any, report: any) {
+  need(draft, ["nodes", "groups", "edges"], "seed infra draft");
+  need(report, ["inputs", "unmatched", "skipped", "skippedCount", "notes", "withheld"], "seed infra report");
+  return {
+    counts: { nodes: draft.nodes.length, groups: draft.groups.length, edges: draft.edges.length,
+      flows: Array.isArray(draft.flows) ? draft.flows.length : 0 },
+    environments: (draft.environments ?? []).map((e: any) => e.id),
+    nodes: draft.nodes.slice(0, 50).map((n: any) => ({
+      id: n.id, category: n.category, provider: n.provider, service: n.service, iac: n.iac, environments: n.environments,
+    })),
+    inputs: report.inputs,
+    unmatched: Object.fromEntries(Object.entries(report.unmatched).map(([provider, u]: [string, any]) =>
+      [provider, { count: u.count, items: (u.items ?? []).slice(0, FIRST) }])),
+    notDrawn: report.notDrawn ?? {},
+    skipped: { count: report.skippedCount, first: report.skipped.slice(0, FIRST) },
+    notes: report.notes.slice(0, FIRST),
+    withheld: report.withheld,
+  };
+}
+
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "infra_seed",
+    "Draft the server room's model from the project's IaC, config files and code with `jsonui-doc seed infra` (Compose, Terraform/OpenTofu, Kubernetes, CloudFormation/SAM/CDK, wrangler, Firebase/PaaS files, SDK imports and env var names — never Terraform state, tfvars or .env values). Returns the draft's counts and nodes (id, category, provider, service, iac), what was read, what could not be placed (unmatched, by provider) or was skipped, and notes. By default nothing in the project is written; write: true writes <infra.dir>/seed/draft.json and seed-report.json (a starting point to copy from — the model is docs/infra/*.json).",
+    {
+      project_dir: z.string().optional().describe("Project directory with jui.config.json (overrides JUI_PROJECT_DIR env)"),
+      write: z.boolean().optional().describe("Write the draft to <infra.dir>/seed in the project (default false: read only)"),
+      force: z.boolean().optional().describe("With write: replace a draft already there"),
+    },
+    async ({ project_dir, write, force }) => {
+      const temp = write ? null : mkdtempSync(join(tmpdir(), "jui-mcp-seed-"));
+      try {
+        const projectDir = config.resolveProjectDir(project_dir);
+        const out = temp ?? join(projectDir, infraDir(projectDir), "seed");
+        const args = ["seed", "infra", projectDir, "-o", out];
+        if (write && force) args.push("--force");
+        const result = await runCli("jsonui-doc", args, { cwd: projectDir, timeout: 180_000 });
+        if (result.exitCode !== 0 || !existsSync(join(out, "draft.json"))) {
+          return text({ ok: false, exit: result.exitCode,
+            message: (result.stderr || result.stdout).trim().split("\n").slice(-5).join("\n") });
+        }
+        const summary = summarize(readJson(join(out, "draft.json"), "draft.json"),
+          readJson(join(out, "seed-report.json"), "seed-report.json"));
+        return text({ ok: true, exit: 0, written: write ? out : null, ...summary });
+      } catch (e: any) {
+        return failure(e);
+      } finally {
+        if (temp) rmSync(temp, { recursive: true, force: true });
+      }
+    }
+  );
+}

package/src/tools/infra/infra_validate.ts

@@ -0,0 +1,44 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { failure, need, problems, runDocJson, text } from "./infra_common.js";
+
+/**
+ * `jsonui-doc validate infra <project> --json`: the room's model (docs/infra/*.json, or jui.config.json's infra.dir)
+ * read as jui viz reads it — each file against the schema and the shapes of secrets, then merged, and its flows
+ * walked. Exit 0: no error (warnings alone are 0); 1: errors; 2: nothing could be read (reason).
+ */
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "infra_validate",
+    "Validate the server room's infra model (docs/infra/*.json: environments, groups, nodes, edges, flows) with `jsonui-doc validate infra --json`. Returns whether it could be read (and why not), the files used, the counts, and the problems by severity and code with the first 20 (file, path, code, message). Flow problems (flow.*) name the rule a step most likely missed. Needs jsonui-cli 2.3.15+.",
+    {
+      project_dir: z.string().optional().describe("Project directory with jui.config.json (overrides JUI_PROJECT_DIR env)"),
+    },
+    async ({ project_dir }) => {
+      try {
+        const projectDir = config.resolveProjectDir(project_dir);
+        const { exitCode, data } = await runDocJson(["validate", "infra", projectDir, "--json"], projectDir);
+        need(data, ["ok"], "validate infra");
+        if (!data.ok && data.reason !== "invalid") {
+          need(data, ["reason", "message"], "validate infra");
+          return text({ ok: false, exit: exitCode, readable: false, reason: data.reason, message: data.message });
+        }
+        need(data, ["dir", "files", "problems"], "validate infra");
+        return text({
+          ok: exitCode === 0,
+          exit: exitCode,
+          readable: data.ok,
+          dir: data.dir,
+          files: data.files,
+          environments: (data.environments ?? []).map((e: any) => e.id),
+          counts: data.counts ?? null,
+          flows: Array.isArray(data.flows) ? data.flows.length : null,
+          problems: problems(data.problems, "validate infra"),
+        });
+      } catch (e: any) {
+        return failure(e);
+      }
+    }
+  );
+}

package/tests/fixtures/infra/RECORDED_FROM

@@ -0,0 +1 @@
+7479faaf infra arms: a load with warnings alone is cost infra's 0 (still counted), and a price dropped by two rows warns once