reworked infra role to work with cardano-up

Author: rober-m

docs/ADDING_A_TOOL.md

@@ -174,6 +174,33 @@ dev:
 
 Write the keys idempotently (replace in place rather than appending) so repeated `just dev` runs don't accumulate duplicate lines. Off-chain/devnet consumers read these and never need to know which tool wrote them.
 
+**Infrastructure providers are added as data, not a new template.** The infra role is backed by a single shared `cardano-up` driver (`templates/_infra/cardano-up`), and all selected providers aggregate into one `infra/` component. To add a provider (e.g. `dolos`), you write only a `registry/tools/<provider>.toml` — no template:
+
+```toml
+[tool]
+id = "dolos"
+name = "Dolos"
+description = "…"
+website = "https://…"
+languages = []                       # infra providers have no user-facing language
+system_deps = ["docker", "cardano-up"]
+detect = []                          # infra is scanned by a driver marker, not per-tool
+
+[roles.infrastructure]
+template = "_infra/cardano-up"       # always the shared driver
+
+[infra]
+cardano_up_package = "dolos"         # the `cardano-up install` package id
+# Map cardano-up's `context env` outputs → contract .env keys. A mapping for an
+# existing key (e.g. NODE_SOCKET_PATH) overrides the default at generation time.
+env = [{ from = "DOLOS_SOCKET_PATH", to = "NODE_SOCKET_PATH" }]
+```
+
+If a mapping targets a contract `.env` key that isn't seeded yet (a brand-new
+connection var), promote it: add a `contract::ENV_*` constant and a seeded
+`KEY=` line in `templates/_base/env.jinja` so every project always carries it.
+See `docs/proposals/infra-via-cardano-up.md` for the full model.
+
 **Devnet tools** provision a local throwaway chain. They should read both the blueprint and the `.env` if they are present, but must work if neither exists, and write the connection vars above during `dev` — that is how off-chain components reach the devnet, and it composes with any off-chain tool without per-pair code.
 
 **Formal-methods tools** have no extra contract beyond the four Justfile targets.

docs/ARCHITECTURE.md

@@ -145,7 +145,7 @@ pub struct FileEntry { dest: PathBuf, source: TemplateSource, render: bool }
 pub enum TemplateSource { Base(String), Role(String), Optional(String), Inline(Vec<u8>) }
 ```
 
-`TemplateContext` is `Serialize` and is the entire surface templates can see. It carries `has_*` booleans per role, an `Option<RoleContext>` per single-tool role, `infra_tools: Vec<RoleContext>`, the contract constants (`blueprint_path`, `env_vars`), and Nix info. `render` is derived from the `.jinja` extension.
+`TemplateContext` is `Serialize` and is the entire surface templates can see. It carries `has_*` booleans per role, an `Option<RoleContext>` per single-tool role, `infra_tools: Vec<InfraToolContext>` plus `infra_context_name` and the resolved `infra_env` (the aggregated infra component, TECH_SPEC §4.6), the contract constants (`blueprint_path`, `env_vars`), and Nix info. `render` is derived from the `.jinja` extension.
 
 ---
 
@@ -225,7 +225,7 @@ Walks `selection.assignments`, resolves each tool against the registry, and buil
 Produces the ordered `FilePlan`:
 1. **Base layer** (always): `Justfile`, `README.md`, `.gitignore`, `.env`.
 2. **Blueprint dir**: `blueprint/.gitkeep`, emitted whenever the selection includes any blueprint-producing-or-consuming role: i.e., any role **except** infrastructure (equivalently: present unless the project is infrastructure-only).
-3. **Role layers**: for each assignment, read the template's `manifest.toml` and add its files. Infrastructure tools each nest under `infra/<tool_id>/`.
+3. **Role layers**: for each assignment, read the template's `manifest.toml` and add its files. **Infrastructure is special — it aggregates**: all selected infra tools share one driver template (`_infra/cardano-up`) emitted **once** at `infra/`, rendered over the full set (`TemplateContext.infra_tools`). This is because the infra engine (`cardano-up`) manages the whole stack as a single unit, not per service. Every other role is one tool → one directory. See `docs/proposals/infra-via-cardano-up.md`.
 4. **Optional layer**: `flake.nix` + `.envrc` when `nix` is set.
 
 No I/O: only embedded assets are read. `render` is set from the `.jinja` extension.

docs/ROADMAP.md

@@ -33,7 +33,7 @@ Deliverables below are tracked as checklists (`[ ]` = not yet done).
 **The tool: all five roles present, four building green, formal-methods preview:**
 - [ ] **On-chain:** Aiken; make the template genuinely `build`+`test` green (blueprint at canonical path).
 - [ ] **Off-chain:** MeshJS + Tx3; both generate and build.
-- [ ] **Infrastructure:** no tool ships yet — the role is present in the vocabulary but unfilled (a real deployable service such as Kupo+Ogmios or a node provider is a follow-up). Yaci DevKit fills the **devnet** role instead (it is a dev/test kit, never deployed).
+- [x] **Infrastructure:** filled via `cardano-up` — **Kupo, Ogmios, Dolos, Tx Submit API, Cardano Node, Cardano Node API, and Dingo** ship as selectable providers that aggregate into a single `infra/` component (one cardano-up context per project). Adding further providers is pure data (a registry TOML, no template). Uses `cardano-up`'s released `--context` flag (blinklabs-io#294; see `docs/proposals/infra-via-cardano-up.md`). Yaci DevKit remains in the **devnet** role (it is a dev/test kit, never deployed).
 - [ ] **Devnet:** Yaci DevKit (local devnet — its `dev` starts a Blockfrost-compatible devnet and writes the standard `.env` connection vars, so off-chain connects to it automatically; `test` runs an integration smoke test).
 - [ ] **Formal-methods:** preview; visible in the registry/UI as "coming soon"; the Blaster placeholder is not a build-green deliverable yet (made real at DX.05).
 

docs/TECH_SPEC.md

@@ -123,19 +123,35 @@ id          = "aiken"          # required, unique across registry, kebab
 name        = "Aiken"          # required, human display
 description = "…"              # required, newcomer-facing
 website      = "https://…"     # required
-languages    = ["aiken"]       # required, ≥1
+languages    = ["aiken"]       # required, ≥1 — except infra tools, which may use [] (no user-facing language)
 system_deps  = ["aiken"]       # required (may be []); abstract dep ids → registry/deps.toml (§9)
 nix_packages = ["aiken"]       # optional (default []); nixpkgs attrs for the dev shell
 
 [roles.on-chain]               # ≥1 [roles.<kebab>] block; key validated against Role
 template = "aiken/on-chain"    # required; path under templates/
 ```
 
+Tools filling the **infrastructure** role additionally require an `[infra]` table
+(validated at load: `[roles.infrastructure]` present ⇒ `[infra]` required, else
+`RegistryError::InfraConfigMissing`). It declares the `cardano-up` package and the
+output→`.env`-key mappings the aggregated driver writes (see the infra-via-cardano-up proposal):
+
+```toml
+[roles.infrastructure]
+template = "_infra/cardano-up"        # the shared driver template (all infra tools use this)
+
+[infra]
+cardano_up_package = "kupo"           # package id passed to `cardano-up install`
+env = [{ from = "KUPO_URL", to = "INDEXER_URL" }]   # cardano-up output → contract .env key
+```
+
 `system_deps` is **per-tool, flat** (§9.1): it applies whenever the tool is selected for any role.
 
 ```rust
 RoleConfig { template }
-ToolDef { id, name, description, website, languages, nix_packages, roles: HashMap<Role, RoleConfig> }
+EnvMapping { from, to }
+InfraConfig { cardano_up_package, env: Vec<EnvMapping> }
+ToolDef { id, name, description, website, languages, nix_packages, detect, roles: HashMap<Role, RoleConfig>, infra: Option<InfraConfig> }
 ```
 
 Load-time validation (`registry/loader.rs`), all fatal:
@@ -206,7 +222,7 @@ MiniJinja environment (planned config):
 
 ### 4.4 Path safety & destinations
 
-- `dest` is resolved **relative to the role dir** (`on-chain/`, `off-chain/`, `test/`, `formal-methods/`); for infrastructure, relative to `infra/<tool_id>/`.
+- `dest` is resolved **relative to the role dir** (`on-chain/`, `off-chain/`, `test/`, `formal-methods/`); for infrastructure, relative to `infra/` (the aggregated component — no per-tool subdir, §6.1).
 - `dest` MUST be relative and MUST NOT contain `..` or a leading `/` (no escaping the project root). Enforced + tested. (Manifests are first-party today, but the check is cheap insurance and required if templates ever become third-party.)
 - Base/optional layer dests are fixed (§6).
 
@@ -228,10 +244,13 @@ struct TemplateContext {
 
     on_chain: Option<RoleContext>,
     off_chain: Option<RoleContext>,
-    infra_tools: Vec<RoleContext>,   // 0..n, canonical order (§11)
+    infra_tools: Vec<InfraToolContext>,  // 0..n, canonical order (§11); aggregated infra component
     devnet: Option<RoleContext>,
     formal_methods: Option<RoleContext>,
 
+    infra_context_name: String,      // cardano-up context the infra driver targets (= project_name)
+    infra_env: Vec<EnvMapping>,      // resolved, key-unique .env emissions for infra (proposal §5.4)
+
     blueprint_path: String,          // "blueprint/plutus.json" (contract constant)
     env_vars: <ordered map>,         // see §6.3; iterated in sorted-key order
 
@@ -240,6 +259,8 @@ struct TemplateContext {
 }
 
 struct RoleContext { tool_id, tool_name, language, dir }   // language = tool.languages[0]
+struct InfraToolContext { tool_id, tool_name, cardano_up_package, env: Vec<EnvMapping> }
+struct EnvMapping { from, to }   // cardano-up output var → contract .env key
 ```
 
 This struct is the contract. Adding a field is additive; renaming/removing is a breaking template-API change.
@@ -262,7 +283,7 @@ Determinism note: any consumer that emits tools/roles must sort (§11), since `b
 
 1. **Base layer** (always): `Justfile`, `README.md`, `.gitignore`, `.env`.
 2. **Blueprint dir**: `blueprint/.gitkeep`, **if  any non-infrastructure role is present** (§6.2). Source is `TemplateSource::Inline(empty)`.
-3. **Role layers**: assignments processed in **`Role::ALL` order** (not flag order). For each, read the template manifest and append its files (rendered per §4.2). Infra tools nested under `infra/<tool_id>/`, **tools sorted by `tool_id`** (§11).
+3. **Role layers**: assignments processed in **`Role::ALL` order** (not flag order). For each, read the template manifest and append its files (rendered per §4.2). **Infrastructure aggregates**: all selected infra tools share one driver template (`_infra/cardano-up`), emitted **once** at `infra/` on the first infra assignment (the rest are contiguous after the canonical sort and skipped); they are still sorted by `tool_id` for the rendered `infra_tools`/`infra_env` order (§11). All infra tools must resolve to the same template path, else `ScaffoldError::InfraTemplateMismatch`. See `docs/proposals/infra-via-cardano-up.md`.
 4. **Optional layer**: if `nix`, `flake.nix` (rendered) + `.envrc` (`Inline "use flake\n"`).
 
 `--dry-run` returns this `FilePlan` (no rendering, no I/O).
@@ -311,7 +332,7 @@ The top level aggregates only the tasks that **terminate and compose**:
 
 ### 7.2 No top-level `dev`
 
-There is **no top-level `dev` target**. Long-running / interactive tasks (watch modes, local devnets, REPLs) do not aggregate into one foreground command — that is exactly why a multi-service launcher is awkward — so they are **per-component**: the developer runs `just -f <role>/Justfile dev` (or `just -f infra/<tool>/Justfile dev`) directly, documented in the README.
+There is **no top-level `dev` target**. Long-running / interactive tasks (watch modes, local devnets, REPLs) do not aggregate into one foreground command — that is exactly why a multi-service launcher is awkward — so they are **per-component**: the developer runs `just -f <role>/Justfile dev` (or `just -f infra/Justfile dev` for the aggregated infra stack) directly, documented in the README.
 
 `dev` is **optional per component** (§7): a tool provides it only when it has a genuine watch/daemon/devnet mode. Because the top level never aggregates `dev`, a component without one costs nothing — and we don't ship no-op `dev` targets just to fill the slot.
 
@@ -507,6 +528,8 @@ The standalone `cardano-init doctor` takes **no flags describing the project**:
 3. A tool matches if **any** of its `detect` signatures matches. Exactly one match ⇒ the component is identified; zero (or an ambiguous multiple) ⇒ the directory is reported as **unrecognized** (renamed, modified, or a foreign project). A renamed *directory* simply isn't found, so that role is absent.
 4. The required set is `{just}` ∪ the `system_deps` of every identified tool (§9.1), fed to the resolver (§9.4).
 
+**Infrastructure is the exception.** The aggregated `infra/` component has no per-tool subdirs (it's the single cardano-up driver), so it is *not* matched against per-tool `detect` signatures. Instead the scan recognizes it by a driver marker — `infra/Justfile` referencing `cardano-up` — and reports a synthetic `cardano-up` component (`doctor::INFRA_DRIVER_ID`). Its contribution to the required set is the **union of all registered infra tools' `system_deps`** (`{docker, cardano-up}`), data-driven from the registry. So infra tools carry `detect = []`.
+
 **Detect signatures (`detect` in `registry/tools/<tool>.toml`).** A list; each entry is either:
 - a **bare path** (relative to the role dir) — matches if the file exists; or
 - a **table** `{ file = "<path>", contains = "<substring>" }` — matches if the file exists *and* its text contains the substring.

registry/deps.toml

@@ -53,8 +53,8 @@ install = [{ npm = "@aiken-lang/aikup" }, { curl = "https://install.aiken-lang.o
 
 [cardano-up]
 binaries = ["cardano-up"]
-docs = "https://github.com/cardano-foundation/cardano-up"
-install = [{ npm = "@cardano-foundation/cardano-up" }, { nix = "cardano-up" }]
+docs = "https://github.com/blinklabs-io/cardano-up"
+install = [{ go = "github.com/blinklabs-io/cardano-up/cmd/cardano-up@latest" }]
 
 [rustup]
 binaries = ["rustup"]

registry/tools/cardano-node-api.toml

@@ -0,0 +1,20 @@
+[tool]
+id = "cardano-node-api"
+name = "Cardano Node API"
+description = """\
+A multi-protocol API in front of a local Cardano node, exposing its functions \
+over gRPC (UTxO RPC) and REST. Useful when off-chain code prefers a modern API \
+to the raw node protocols. Run as infrastructure via cardano-up (which pulls \
+in a Cardano node automatically). Its gRPC endpoint is published to the \
+project .env as CARDANO_NODE_API_URL, and the node socket as NODE_SOCKET_PATH."""
+website = "https://github.com/blinklabs-io/cardano-node-api"
+languages = []
+system_deps = ["docker", "cardano-up"]
+nix_packages = []
+
+[roles.infrastructure]
+template = "_infra/cardano-up"
+
+[infra]
+cardano_up_package = "cardano-node-api"
+env = [{ from = "CARDANO_NODE_API_GRPC", to = "CARDANO_NODE_API_URL" }]

registry/tools/cardano-node.toml

@@ -0,0 +1,23 @@
+[tool]
+id = "cardano-node"
+name = "Cardano Node"
+description = """\
+The reference Cardano node. Choose this when you just want a synced local node \
+and its UNIX socket — no indexer or query layer — for tools that talk to the \
+node directly. Run as infrastructure via cardano-up. The socket path is \
+published to the project .env as NODE_SOCKET_PATH. Pair it with an off-chain \
+tool that uses the socket, or add an indexer/query provider (kupo, ogmios) for \
+a fuller stack."""
+website = "https://github.com/IntersectMBO/cardano-node"
+languages = []
+system_deps = ["docker", "cardano-up"]
+nix_packages = []
+
+[roles.infrastructure]
+template = "_infra/cardano-up"
+
+[infra]
+# Only a node socket. The driver's base default already maps
+# CARDANO_NODE_SOCKET_PATH → NODE_SOCKET_PATH, so no explicit mapping is needed.
+cardano_up_package = "cardano-node"
+env = []

registry/tools/dingo.toml

@@ -0,0 +1,24 @@
+[tool]
+id = "dingo"
+name = "Dingo"
+description = """\
+A Cardano node implementation from Blink Labs with batteries included: it \
+syncs the chain and serves a Blockfrost-compatible HTTP API alongside its own \
+node socket — a single all-in-one process. Run as infrastructure via \
+cardano-up (it does not run a separate cardano-node). Its Blockfrost-compatible \
+API is published to the project .env as INDEXER_URL and its socket as \
+NODE_SOCKET_PATH, so off-chain components connect to it automatically."""
+website = "https://github.com/blinklabs-io/dingo"
+languages = []
+system_deps = ["docker", "cardano-up"]
+nix_packages = []
+
+[roles.infrastructure]
+template = "_infra/cardano-up"
+
+[infra]
+cardano_up_package = "dingo"
+env = [
+    { from = "DINGO_BLOCKFROST", to = "INDEXER_URL" },
+    { from = "DINGO_SOCKET_PATH", to = "NODE_SOCKET_PATH" },
+]

registry/tools/dolos.toml

@@ -0,0 +1,24 @@
+[tool]
+id = "dolos"
+name = "Dolos"
+description = """\
+A lightweight Cardano data node. Dolos syncs the chain and serves it over a \
+UTxO RPC (gRPC) interface — a single process that replaces a full node plus \
+separate indexer for many off-chain needs. Run as infrastructure via \
+cardano-up. It provides its own node socket (it does not run a separate \
+cardano-node), published to the project .env as NODE_SOCKET_PATH, and its gRPC \
+endpoint as DOLOS_GRPC_URL."""
+website = "https://github.com/txpipe/dolos"
+languages = []
+system_deps = ["docker", "cardano-up"]
+nix_packages = []
+
+[roles.infrastructure]
+template = "_infra/cardano-up"
+
+[infra]
+cardano_up_package = "dolos"
+env = [
+    { from = "DOLOS_GRPC", to = "DOLOS_GRPC_URL" },
+    { from = "DOLOS_SOCKET_PATH", to = "NODE_SOCKET_PATH" },
+]

registry/tools/kupo.toml

@@ -0,0 +1,21 @@
+[tool]
+id = "kupo"
+name = "Kupo"
+description = """\
+A fast, lightweight chain-index for Cardano. Kupo watches the chain for \
+addresses, policy ids, or transaction outputs you care about and serves them \
+over a simple HTTP API — ideal as the indexer behind an off-chain app. Run as \
+infrastructure via cardano-up, which also pulls in a Cardano node \
+automatically. Its endpoint is published to the project .env as INDEXER_URL, \
+so off-chain components connect to it without extra wiring."""
+website = "https://github.com/CardanoSolutions/kupo"
+languages = []
+system_deps = ["docker", "cardano-up"]
+nix_packages = []
+
+[roles.infrastructure]
+template = "_infra/cardano-up"
+
+[infra]
+cardano_up_package = "kupo"
+env = [{ from = "KUPO_URL", to = "INDEXER_URL" }]