insightfactory-cli 1.0.3.dev17__tar.gz → 1.0.3.dev19__tar.gz

{insightfactory_cli-1.0.3.dev17 → insightfactory_cli-1.0.3.dev19}/CLAUDE.md

@@ -16,11 +16,14 @@ uv run ty check
 ## Conventions
 
 - Keep one module per CLI command under `src/if_cli/commands/`.
+- The base install has no runtime dependencies. Optional features live in
+  extras and are imported lazily inside their command module.
 - Never send a profile bearer token outside that profile's factory origin.
 - OAuth uses authorization-code flow with PKCE and a loopback-only callback.
 - Store profiles and tokens through the atomic private-file helpers.
-- On-disk profile/token-store paths and JSON shapes stay compatible with the
-  Node CLI (`~/.insightfactory`, `INSIGHTFACTORY_CONFIG_DIR` override).
+- The Node CLI is retired; `[factory <name>]` sections are Python-only. Profile
+  sections and the token store keep the Node layout (`~/.insightfactory`,
+  `INSIGHTFACTORY_CONFIG_DIR` override).
 - Do not commit credentials, access tokens, refresh tokens, or client secrets.
 - Test fixtures use only neutral hostnames (`factory.example`).
 - Do not publish to PyPI from a developer machine. Publishing happens in CI: the

insightfactory_cli-1.0.3.dev17/README.md → insightfactory_cli-1.0.3.dev19/PKG-INFO

@@ -1,3 +1,27 @@
+Metadata-Version: 2.5
+Name: insightfactory-cli
+Version: 1.0.3.dev19
+Summary: Profile-based authentication CLI for the InsightFactory Interfaces API
+Project-URL: Homepage, https://insightfactory.ai
+Author-email: "insightfactory.ai Support" <support@insightfactory.ai>
+License-Expression: LicenseRef-Proprietary
+License-File: LICENSE
+Keywords: cli,insightfactory,oauth,pkce
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: mcp
+Requires-Dist: anyio; extra == 'mcp'
+Requires-Dist: exceptiongroup; (python_version < '3.11') and extra == 'mcp'
+Requires-Dist: httpx2; extra == 'mcp'
+Requires-Dist: mcp-types; extra == 'mcp'
+Requires-Dist: mcp<3,>=2.1; extra == 'mcp'
+Description-Content-Type: text/markdown
+
 # insightfactory-cli
 
 Profile-based authentication CLI for the InsightFactory Interfaces API. It
@@ -183,6 +207,15 @@ write to stdout, never launch a browser or block on interactive input, and only
 use bounded waits. Changing or removing any of them is a breaking change and
 needs a major version bump.
 
+`get_valid_token` takes a keyword-only `force_refresh` (default `False`). When
+`True`, it refreshes the cached token even if it is still fresh, which a
+caller that just received a 401 from the factory needs: the cached token was
+fresh a moment ago but the factory has since rejected it. With a refresh
+token cached, this re-mints regardless of freshness; without one — a token
+pasted through `if-cli set-token` — it raises `CliError` with the same
+`if-cli login -p <name>` hint rather than serving the token that was just
+rejected.
+
 ## How authentication works
 
 - Profiles live in `~/.insightfactory/config`, one per customer and environment.
@@ -201,6 +234,76 @@ needs a major version bump.
   the client ID from the factory's discovery document at runtime and holds no
   client secret.
 
+## MCP router (`if-cli mcp`)
+
+Runs one MCP server over stdio that fronts several factory environments as a
+single tool catalogue, instead of one MCP connection per environment. Every
+tool gets a required `environment` argument and each call is forwarded to
+that environment's own factory `/mcp` endpoint, authenticated with that
+environment's `if-cli` profile — a profile's bearer token never reaches a
+different environment's host. A tool is only offered on the environments
+whose input schema matches the published one, so a factory on an older
+release cannot be handed argument shapes it does not accept.
+
+It needs the `mcp` extra, which is not part of the base install. Name its environments once
+in a `[factory <name>]` section of `~/.insightfactory/config`, alongside profiles:
+
+```ini
+[factory foundry]
+dev = example-dev
+tst = example-tst
+writable = dev
+```
+
+Every key except `writable` and `catalog` is `<environment code> = <profile name>`; file
+order is the environment order. `writable` is a comma-separated list of codes (default
+none); `catalog` is one code (default the first environment). Then:
+
+```bash
+uv tool install 'insightfactory-cli[mcp]'
+uvx --from 'insightfactory-cli[mcp]' if-cli mcp foundry
+```
+
+Add it to `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "if-factory": {
+      "command": "uvx",
+      "args": ["--from", "insightfactory-cli[mcp]", "if-cli", "mcp", "foundry"]
+    }
+  }
+}
+```
+
+`--env`, `--writable`, `--catalog` and `--allow-tool` still work without a factory section
+(`--env` is required in that case), and each one overrides the section when both are given:
+a repeated `--env CODE=PROFILE` replaces that code's profile, `--writable`/`--catalog`, when
+passed at all, replace the section's value outright, and `--allow-tool` is always additive.
+
+| Flag | Meaning |
+|---|---|
+| `FACTORY` (optional, first positional) | Name of a `[factory <name>]` config section supplying the flags below. |
+| `--env CODE=PROFILE` (repeatable, required without `FACTORY`) | The environment code the model passes, mapped to the `if-cli` profile that reaches it. |
+| `--writable CODE` (repeatable) | Environments where write tools are allowed. Everything else is read-only. |
+| `--read-only` | Forces every environment read-only, overriding both the section's `writable` and any `--writable`. Cannot be combined with `--writable`. |
+| `--catalog CODE` (default: the first environment) | Whose tool list is published; its schemas are the reference every environment is checked against. |
+| `--allow-tool NAME` (repeatable) | Extra tool names treated as read-only, beyond the shipped list. |
+| `--timeout SECONDS` (default `120`) | Per upstream request; higher than the `api` command's default because some tools are slow. |
+
+`mcp`'s `--timeout` does not read `INSIGHTFACTORY_REQUEST_TIMEOUT`: it parses the flag with
+`parse_timeout_seconds` rather than `resolve_request_timeout`, because a long-running stdio
+server is not the one-shot request that environment variable is scoped to.
+
+Only environments passed to `--writable` accept mutating tools; every other
+environment allows only tools it knows to read (an allowlist, not a
+blocklist — a tool the model reaches through `invoke_tool` is never in the
+published catalogue, so a blocklist could never cover everything callable).
+Passing dev-only writes to production means changing an argument value, not
+connecting to a different server, so keep `--writable` scoped to the
+environments meant to be written by hand.
+
 ## Development
 
 ```bash
@@ -218,7 +321,9 @@ uv run if-cli --version
 INSIGHTFACTORY_CONFIG_DIR=$(mktemp -d) uv run if-cli profiles
 ```
 
-Python 3.10 or newer is required. Runtime code is stdlib-only.
+Python 3.10 or newer is required. The base install has no runtime dependencies;
+optional features, such as `if-cli mcp`, ship as extras and are imported lazily
+inside their command module.
 
 ## Release
 

insightfactory_cli-1.0.3.dev17/PKG-INFO → insightfactory_cli-1.0.3.dev19/README.md

@@ -1,21 +1,3 @@
-Metadata-Version: 2.5
-Name: insightfactory-cli
-Version: 1.0.3.dev17
-Summary: Profile-based authentication CLI for the InsightFactory Interfaces API
-Project-URL: Homepage, https://insightfactory.ai
-Author-email: "insightfactory.ai Support" <support@insightfactory.ai>
-License-Expression: LicenseRef-Proprietary
-License-File: LICENSE
-Keywords: cli,insightfactory,oauth,pkce
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: License :: Other/Proprietary License
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Typing :: Typed
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-
 # insightfactory-cli
 
 Profile-based authentication CLI for the InsightFactory Interfaces API. It
@@ -201,6 +183,15 @@ write to stdout, never launch a browser or block on interactive input, and only
 use bounded waits. Changing or removing any of them is a breaking change and
 needs a major version bump.
 
+`get_valid_token` takes a keyword-only `force_refresh` (default `False`). When
+`True`, it refreshes the cached token even if it is still fresh, which a
+caller that just received a 401 from the factory needs: the cached token was
+fresh a moment ago but the factory has since rejected it. With a refresh
+token cached, this re-mints regardless of freshness; without one — a token
+pasted through `if-cli set-token` — it raises `CliError` with the same
+`if-cli login -p <name>` hint rather than serving the token that was just
+rejected.
+
 ## How authentication works
 
 - Profiles live in `~/.insightfactory/config`, one per customer and environment.
@@ -219,6 +210,76 @@ needs a major version bump.
   the client ID from the factory's discovery document at runtime and holds no
   client secret.
 
+## MCP router (`if-cli mcp`)
+
+Runs one MCP server over stdio that fronts several factory environments as a
+single tool catalogue, instead of one MCP connection per environment. Every
+tool gets a required `environment` argument and each call is forwarded to
+that environment's own factory `/mcp` endpoint, authenticated with that
+environment's `if-cli` profile — a profile's bearer token never reaches a
+different environment's host. A tool is only offered on the environments
+whose input schema matches the published one, so a factory on an older
+release cannot be handed argument shapes it does not accept.
+
+It needs the `mcp` extra, which is not part of the base install. Name its environments once
+in a `[factory <name>]` section of `~/.insightfactory/config`, alongside profiles:
+
+```ini
+[factory foundry]
+dev = example-dev
+tst = example-tst
+writable = dev
+```
+
+Every key except `writable` and `catalog` is `<environment code> = <profile name>`; file
+order is the environment order. `writable` is a comma-separated list of codes (default
+none); `catalog` is one code (default the first environment). Then:
+
+```bash
+uv tool install 'insightfactory-cli[mcp]'
+uvx --from 'insightfactory-cli[mcp]' if-cli mcp foundry
+```
+
+Add it to `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "if-factory": {
+      "command": "uvx",
+      "args": ["--from", "insightfactory-cli[mcp]", "if-cli", "mcp", "foundry"]
+    }
+  }
+}
+```
+
+`--env`, `--writable`, `--catalog` and `--allow-tool` still work without a factory section
+(`--env` is required in that case), and each one overrides the section when both are given:
+a repeated `--env CODE=PROFILE` replaces that code's profile, `--writable`/`--catalog`, when
+passed at all, replace the section's value outright, and `--allow-tool` is always additive.
+
+| Flag | Meaning |
+|---|---|
+| `FACTORY` (optional, first positional) | Name of a `[factory <name>]` config section supplying the flags below. |
+| `--env CODE=PROFILE` (repeatable, required without `FACTORY`) | The environment code the model passes, mapped to the `if-cli` profile that reaches it. |
+| `--writable CODE` (repeatable) | Environments where write tools are allowed. Everything else is read-only. |
+| `--read-only` | Forces every environment read-only, overriding both the section's `writable` and any `--writable`. Cannot be combined with `--writable`. |
+| `--catalog CODE` (default: the first environment) | Whose tool list is published; its schemas are the reference every environment is checked against. |
+| `--allow-tool NAME` (repeatable) | Extra tool names treated as read-only, beyond the shipped list. |
+| `--timeout SECONDS` (default `120`) | Per upstream request; higher than the `api` command's default because some tools are slow. |
+
+`mcp`'s `--timeout` does not read `INSIGHTFACTORY_REQUEST_TIMEOUT`: it parses the flag with
+`parse_timeout_seconds` rather than `resolve_request_timeout`, because a long-running stdio
+server is not the one-shot request that environment variable is scoped to.
+
+Only environments passed to `--writable` accept mutating tools; every other
+environment allows only tools it knows to read (an allowlist, not a
+blocklist — a tool the model reaches through `invoke_tool` is never in the
+published catalogue, so a blocklist could never cover everything callable).
+Passing dev-only writes to production means changing an argument value, not
+connecting to a different server, so keep `--writable` scoped to the
+environments meant to be written by hand.
+
 ## Development
 
 ```bash
@@ -236,7 +297,9 @@ uv run if-cli --version
 INSIGHTFACTORY_CONFIG_DIR=$(mktemp -d) uv run if-cli profiles
 ```
 
-Python 3.10 or newer is required. Runtime code is stdlib-only.
+Python 3.10 or newer is required. The base install has no runtime dependencies;
+optional features, such as `if-cli mcp`, ship as extras and are imported lazily
+inside their command module.
 
 ## Release
 

{insightfactory_cli-1.0.3.dev17 → insightfactory_cli-1.0.3.dev19}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "insightfactory-cli"
-version = "1.0.3.dev17"
+version = "1.0.3.dev19"
 description = "Profile-based authentication CLI for the InsightFactory Interfaces API"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -23,12 +23,15 @@ if-cli = "if_cli.main:main"
 [project.urls]
 Homepage = "https://insightfactory.ai"
 
+[project.optional-dependencies]
+mcp = ["mcp>=2.1,<3", "anyio", "httpx2", "mcp-types", "exceptiongroup; python_version < '3.11'"]
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [dependency-groups]
-dev = ["pytest", "ruff", "ty"]
+dev = ["pytest", "ruff", "ty", "insightfactory-cli[mcp]"]
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/if_cli"]

{insightfactory_cli-1.0.3.dev17 → insightfactory_cli-1.0.3.dev19}/src/if_cli/cli.py

@@ -53,6 +53,8 @@ def _parse_args_with_positionals(argv: list[str], *, options: Options) -> tuple[
     """Parse argv allowing options and positionals in any order (Node util.parseArgs parity)."""
     values: dict[str, Any] = {}
     for name, spec in options.items():
+        if spec.get("repeat"):
+            die(f"internal error: option '--{name}' has repeat=True, which allow_positionals parsing does not support")
         if spec["type"] == "boolean":
             values[name] = spec.get("default", False)
         else:
@@ -136,6 +138,10 @@ def parse_args(
         dest = name.replace("-", "_")
         if spec["type"] == "boolean":
             parser.add_argument(*flags, dest=dest, action="store_true", default=spec.get("default", False))
+        elif spec.get("repeat"):
+            # `action="append"` with `default=None` (rather than a spec-level `[]`) so
+            # unset stays None and a shared mutable default can't leak across calls.
+            parser.add_argument(*flags, dest=dest, action="append", default=None)
         else:
             parser.add_argument(*flags, dest=dest, default=spec.get("default"))
     namespace = parser.parse_args(argv)

insightfactory_cli-1.0.3.dev19/src/if_cli/commands/mcp.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+import importlib.util
+import sys
+
+from if_cli.cli import Options, parse_args
+from if_cli.config import config_file, get_profile, list_factories, load_config, parse_factory_section
+from if_cli.http import parse_timeout_seconds
+from if_cli.runtime import die
+
+MCP_OPTIONS: Options = {
+    "env": {"type": "string", "repeat": True},
+    "writable": {"type": "string", "repeat": True},
+    "read-only": {"type": "boolean"},
+    "catalog": {"type": "string"},
+    "allow-tool": {"type": "string", "repeat": True},
+    "timeout": {"type": "string", "default": "120"},
+}
+
+MCP_USAGE = (
+    "usage: if-cli mcp [FACTORY] [--env CODE=PROFILE ...]\n"
+    "                   [--writable CODE ... | --read-only] [--catalog CODE]\n"
+    "                   [--allow-tool NAME ...] [--timeout SECONDS]\n"
+    "\n"
+    "Runs one MCP server over stdio that fronts several factory environments: every\n"
+    "tool gets a required 'environment' argument, routed to that environment's own\n"
+    "if-cli profile. FACTORY names a [factory NAME] section in the config file,\n"
+    "supplying its environments, --writable and --catalog; flags override the\n"
+    "section. Without FACTORY, --env is required at least once. --catalog defaults\n"
+    "to the first environment; environments not passed to --writable are read-only;\n"
+    "--read-only forces every environment read-only and cannot be combined with\n"
+    "--writable.\n"
+)
+
+MISSING_MCP_EXTRA = (
+    "if-cli mcp needs the mcp extra — install with: uv tool install 'insightfactory-cli[mcp]'\n"
+    "(or: uvx --from 'insightfactory-cli[mcp]' if-cli mcp ...)"
+)
+
+
+def _parse_env_mapping(raw: str) -> tuple[str, str]:
+    code, separator, profile_name = raw.partition("=")
+    if not separator or not code or not profile_name:
+        die(f"--env must be CODE=PROFILE (received '{raw}')\n\n{MCP_USAGE}")
+    return code, profile_name
+
+
+def _stray_positional(rest: list[str]) -> str | None:
+    """Find a bare (non-flag) token in `rest`, skipping tokens consumed as a
+    preceding flag's value. `rest` is `argv` with a leading FACTORY already
+    peeled off, so any bare token found here is a second, misplaced one."""
+    index = 0
+    while index < len(rest):
+        token = rest[index]
+        if token == "--":
+            return rest[index + 1] if index + 1 < len(rest) else None
+        if token.startswith("--"):
+            name, has_inline_value, _value = token[2:].partition("=")
+            spec = MCP_OPTIONS.get(name)
+            if spec is not None and spec["type"] != "boolean" and not has_inline_value:
+                index += 2
+                continue
+            index += 1
+            continue
+        if token.startswith("-") and len(token) > 1:
+            index += 1
+            continue
+        return token
+    return None
+
+
+def mcp_command(argv: list[str]) -> None:
+    if "-h" in argv or "--help" in argv:
+        sys.stdout.write(MCP_USAGE)
+        return
+
+    factory_name: str | None = None
+    rest = argv
+    if argv and not argv[0].startswith("-"):
+        factory_name, *rest = argv
+
+    stray = _stray_positional(rest)
+    if stray is not None:
+        die(f"FACTORY must come before the flags: if-cli mcp {stray} --env ...\n\n{MCP_USAGE}")
+
+    values, _positionals = parse_args(rest, options=MCP_OPTIONS)
+    raw_envs: list[str] = values["env"] or []
+    raw_writable: list[str] | None = values["writable"]
+    read_only: bool = values["read-only"]
+
+    if read_only and raw_writable is not None:
+        die(f"--read-only cannot be combined with --writable\n\n{MCP_USAGE}")
+
+    config = load_config()
+
+    # A dict, not a list of pairs: --env "adds or replaces that code's profile"
+    # (a factory's own environments first, then each --env in turn), so a
+    # repeated code is the way to override one, not a mistake to reject.
+    # Overriding an existing code keeps its original position (a dict update,
+    # not a delete-and-reinsert), which is what keeps the --catalog default
+    # (codes[0]) stable under a partial override.
+    mappings: dict[str, str] = {}
+    writable_codes: frozenset[str] = frozenset()
+    catalog_source: str | None = None
+
+    if factory_name is not None:
+        factory = parse_factory_section(config, factory_name)
+        mappings.update(factory["environments"])
+        writable_codes = factory["writable"]
+        catalog_source = factory["catalog"]
+
+    for raw in raw_envs:
+        code, profile_name = _parse_env_mapping(raw)
+        mappings[code] = profile_name
+
+    if not mappings:
+        factories = sorted(list_factories(config))
+        hint = f" or name one of the factories in {config_file()}: {', '.join(factories)}" if factories else ""
+        die(f"--env is required (at least one){hint}\n\n{MCP_USAGE}")
+    codes = list(mappings)
+
+    if read_only:
+        writable_codes = frozenset()
+    elif raw_writable is not None:
+        writable_codes = frozenset(raw_writable)
+    if values["catalog"] is not None:
+        catalog_source = values["catalog"]
+    if catalog_source is None:
+        catalog_source = codes[0]
+
+    # Checked with find_spec rather than a bare try/except ImportError so a genuine
+    # import bug inside if_cli.router propagates instead of reading as a missing extra.
+    if importlib.util.find_spec("mcp") is None:
+        die(MISSING_MCP_EXTRA)
+    from if_cli.router.server import build_router, log, run_server
+
+    timeout = parse_timeout_seconds(values["timeout"], "--timeout")
+    extra_read_only = frozenset(values["allow-tool"] or [])
+
+    if catalog_source not in codes:
+        die(f"--catalog '{catalog_source}' is not one of the --env codes: {', '.join(codes)}")
+
+    unknown_writable = sorted(code for code in writable_codes if code not in codes)
+    if unknown_writable:
+        named = ", ".join(f"'{code}'" for code in unknown_writable)
+        die(f"--writable {named} not among the --env codes: {', '.join(codes)}")
+
+    profiles = {code: get_profile(config, profile_name) for code, profile_name in mappings.items()}
+
+    label = factory_name if factory_name is not None else "environments"
+    parts = [
+        f"{code}={mappings[code]} {profiles[code]['host']}{' (writable)' if code in writable_codes else ''}"
+        for code in codes
+    ]
+    log(f"{label}: {'; '.join(parts)}; catalog={catalog_source}")
+
+    router = build_router(
+        profiles=profiles,
+        writable_codes=writable_codes,
+        catalog_source=catalog_source,
+        extra_read_only=extra_read_only,
+        timeout=timeout,
+    )
+    run_server(router)

{insightfactory_cli-1.0.3.dev17 → insightfactory_cli-1.0.3.dev19}/src/if_cli/commands/profiles.py

@@ -8,7 +8,7 @@ from typing import Literal, TypedDict
 from if_cli.cache import TokenCache, is_fresh, load_cache
 from if_cli.cli import Options, parse_args
 from if_cli.colour import Colour, colourise
-from if_cli.config import config_file, get_profile, load_config
+from if_cli.config import config_file, get_profile, is_factory_section, load_config
 from if_cli.runtime import format_expiry
 
 TokenStatus = Literal["valid", "expired", "none", "unknown"]
@@ -41,6 +41,8 @@ def summarize_profiles(
 ) -> list[ProfileSummary]:
     summaries: list[ProfileSummary] = []
     for section in config:
+        if is_factory_section(section):
+            continue
         name = "DEFAULT" if section == "" else section
         try:
             profile = get_profile(config, name)

{insightfactory_cli-1.0.3.dev17 → insightfactory_cli-1.0.3.dev19}/src/if_cli/config.py

@@ -23,6 +23,17 @@ class Profile(TypedDict):
     organization: str | None
 
 
+class Factory(TypedDict):
+    name: str
+    environments: list[tuple[str, str]]
+    writable: frozenset[str]
+    catalog: str
+
+
+FACTORY_SECTION_PREFIX = "factory "
+FACTORY_RESERVED_KEYS = {"writable", "catalog"}
+
+
 def config_dir() -> str:
     if "INSIGHTFACTORY_CONFIG_DIR" in os.environ:
         return os.environ["INSIGHTFACTORY_CONFIG_DIR"]
@@ -163,7 +174,82 @@ def resolve_profile_name(flag: str | None = None) -> str:
     return name
 
 
+def is_factory_section(name: str) -> bool:
+    return name.startswith(FACTORY_SECTION_PREFIX)
+
+
+def list_factories(config: dict[str, dict[str, str]]) -> list[str]:
+    return [section.removeprefix(FACTORY_SECTION_PREFIX) for section in config if is_factory_section(section)]
+
+
+def parse_factory_section(config: dict[str, dict[str, str]], name: str) -> Factory:
+    """Parse a `[factory <name>]` section on its own: no check that a `writable`/
+    `catalog` code is among its environments, and none of its profiles are resolved.
+
+    A caller that means to merge `--env`/`--writable`/`--catalog` overrides on top
+    (`commands/mcp.py`) validates the merged result once, afterwards, rather than
+    validating this unmerged section only to re-validate the effective mapping a
+    second time. `get_factory` below runs both steps for a caller that has no
+    overrides to merge.
+    """
+    section_key = f"{FACTORY_SECTION_PREFIX}{name}"
+    if section_key not in config:
+        known = sorted(list_factories(config))
+        hint = f"known factories: {', '.join(known)}" if known else "no factory sections defined"
+        die(
+            f"factory '{name}' not found in {config_file()} — add a [factory {name}] section with "
+            f"<code> = <profile> lines ({hint})"
+        )
+    section = config[section_key]
+
+    environments = [(code, profile_name) for code, profile_name in section.items() if code not in FACTORY_RESERVED_KEYS]
+    if not environments:
+        die(f"factory '{name}' in {config_file()} has no environments — add <code> = <profile> lines")
+    for code, profile_name in environments:
+        if not profile_name.strip():
+            die(
+                f"factory '{name}' in {config_file()}: environment '{code}' has an empty profile "
+                f"(found '{code} =' with no value)"
+            )
+    codes = [code for code, _profile_name in environments]
+
+    writable = frozenset(code.strip() for code in section.get("writable", "").split(",") if code.strip())
+    catalog_value = section.get("catalog")
+    catalog = catalog_value.strip() if catalog_value is not None and catalog_value.strip() else codes[0]
+
+    return {"name": name, "environments": environments, "writable": writable, "catalog": catalog}
+
+
+def get_factory(config: dict[str, dict[str, str]], name: str) -> Factory:
+    """Parse and fully validate a `[factory <name>]` section: every profile it
+    references exists, and its own `writable`/`catalog` codes are among its own
+    environments. A caller that merges overrides on top of the section should use
+    `parse_factory_section` instead, and validate the merged result once."""
+    factory = parse_factory_section(config, name)
+    codes = [code for code, _profile_name in factory["environments"]]
+
+    unknown_writable = sorted(code for code in factory["writable"] if code not in codes)
+    if unknown_writable:
+        named = ", ".join(f"'{code}'" for code in unknown_writable)
+        die(f"factory '{name}' in {config_file()}: writable {named} not among its environments: {', '.join(codes)}")
+
+    if factory["catalog"] not in codes:
+        die(
+            f"factory '{name}' in {config_file()}: catalog '{factory['catalog']}' is not among its environments: "
+            f"{', '.join(codes)}"
+        )
+
+    for _code, profile_name in factory["environments"]:
+        get_profile(config, profile_name)
+
+    return factory
+
+
 def get_profile(config: dict[str, dict[str, str]], name: str) -> Profile:
+    if is_factory_section(name):
+        die(
+            f"'{name}' is a factory section, not a profile; use: if-cli mcp {name.removeprefix(FACTORY_SECTION_PREFIX)}"
+        )
     section_key = "" if name == "DEFAULT" else name
     if section_key not in config:
         die(f"profile '{name}' not found in {config_file()} — run: if-cli login -p {name} --host <factory-url>")

{insightfactory_cli-1.0.3.dev17 → insightfactory_cli-1.0.3.dev19}/src/if_cli/main.py

@@ -7,6 +7,7 @@ from if_cli.commands.api import api_command
 from if_cli.commands.config import config_command
 from if_cli.commands.login import login_command
 from if_cli.commands.logout import logout_command
+from if_cli.commands.mcp import mcp_command
 from if_cli.commands.profiles import profiles_command
 from if_cli.commands.set_token import set_token_command
 from if_cli.commands.token import token_command
@@ -30,6 +31,12 @@ commands:
               [-p profile] [-X METHOD] [-d DATA] [--timeout SECONDS] <path>
               routes [-p profile] [--timeout SECONDS] [filter]
               describe [-p profile] [--timeout SECONDS] METHOD <path>
+  mcp         run one MCP server that routes across factory environments
+              [FACTORY] [--env CODE=PROFILE ...]
+              [--writable CODE ... | --read-only] [--catalog CODE]
+              [--allow-tool NAME ...] [--timeout SECONDS]
+              FACTORY names a [factory NAME] config section; flags override it
+              (needs the mcp extra: uv tool install 'insightfactory-cli[mcp]')
 
 profile selection: -p flag, then ${ENV_PROFILE}, then [DEFAULT].
 request timeout: --timeout flag, then ${ENV_REQUEST_TIMEOUT}, then 30 seconds.
@@ -60,6 +67,9 @@ def run_cli(argv: list[str]) -> None:
     if command == "api":
         api_command(rest)
         return
+    if command == "mcp":
+        mcp_command(rest)
+        return
     if command in {None, "-h", "--help"}:
         import sys