insightfactory-cli 1.0.2.dev16__py3-none-any.whl → 1.0.3.dev19__py3-none-any.whl

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)

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)

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)

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>")

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
 

if_cli/oauth.py

@@ -346,23 +346,28 @@ def _refresh(host: str, entry: CacheEntry, refresh_token: str, client_id: str) -
     return store_tokens(host, tokens, entry["token_endpoint"], client_id)
 
 
-def _wait_for_fresh_token(host: str) -> str | None:
+def _wait_for_fresh_token(host: str, *, exclude: str | None = None) -> str | None:
     for attempt in range(RECOVERY_POLL_ATTEMPTS):
         entry = load_cache()["tokens"].get(host)
-        if entry and is_fresh(entry):
+        if entry and is_fresh(entry) and entry["access_token"] != exclude:
             return entry["access_token"]
         if attempt + 1 < RECOVERY_POLL_ATTEMPTS:
             time.sleep(RECOVERY_POLL_INTERVAL_MS / 1000)
     return None
 
 
-def get_valid_token(profile: Profile) -> str:
+def get_valid_token(profile: Profile, *, force_refresh: bool = False) -> str:
     entry = load_cache()["tokens"].get(profile["host"])
     if not entry:
         die(f"no cached token for {profile['host']} — run: if-cli login -p {profile['name']}")
-    if is_fresh(entry):
+    if not force_refresh and is_fresh(entry):
         return entry["access_token"]
     refresh_token = entry.get("refresh_token")
+    if force_refresh and not refresh_token:
+        die(
+            f"cannot refresh token for {profile['host']}: no refresh token cached (a pasted static token) — "
+            f"run: if-cli login -p {profile['name']}"
+        )
     if refresh_token:
         client_id = entry.get("client_id")
         if not client_id:
@@ -378,7 +383,9 @@ def get_valid_token(profile: Profile) -> str:
             if isinstance(error, TokenRequestError) and error.invalidates_refresh_token:
                 cleared = clear_refresh_token_if_matches(profile["host"], refresh_token)
                 if cleared:
-                    recovered_access_token = _wait_for_fresh_token(profile["host"])
+                    recovered_access_token = _wait_for_fresh_token(
+                        profile["host"], exclude=entry["access_token"] if force_refresh else None
+                    )
                     if recovered_access_token:
                         return recovered_access_token
                 else:

if_cli/router/catalog.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from typing import Any
+
+from if_cli.runtime import CliError
+
+ENV_ARG = "environment"
+
+
+@dataclass(frozen=True)
+class EnvironmentSpec:
+    code: str
+    label: str
+    writable: bool
+
+
+def fingerprint(schema: dict[str, Any] | None) -> str:
+    """First 12 hex chars of the sha1 of the schema's canonical JSON."""
+    encoded = json.dumps(schema or {}, sort_keys=True, separators=(",", ":"))
+    return hashlib.sha1(encoded.encode("utf-8"), usedforsecurity=False).hexdigest()[:12]  # nosec B324
+
+
+def _offered_environments(
+    tool_name: str,
+    reference: str,
+    catalogues: Mapping[str, list[dict[str, Any]] | None],
+    environments: Sequence[EnvironmentSpec],
+) -> list[str]:
+    offered: list[str] = []
+    for env in environments:
+        remote = catalogues.get(env.code)
+        if remote is None:
+            # Never listed, so nothing to compare. Offer it and let the call fail
+            # with the login hint rather than hiding the environment entirely.
+            offered.append(env.code)
+            continue
+        match = next((candidate for candidate in remote if candidate.get("name") == tool_name), None)
+        if match is None or fingerprint(match.get("inputSchema")) != reference:
+            continue
+        offered.append(env.code)
+    return offered
+
+
+def splice_environment(
+    tool: dict[str, Any], offered: list[str], environments: Sequence[EnvironmentSpec]
+) -> dict[str, Any]:
+    offered_set = set(offered)
+    description = "Which factory environment to run this against. " + (
+        "; ".join(
+            f"{env.code} = {env.label}{'' if env.writable else ' (read-only)'}"
+            for env in environments
+            if env.code in offered_set
+        )
+        + "."
+    )
+    dropped = [env.code for env in environments if env.code not in offered_set]
+    if dropped:
+        description += (
+            f" Not available on {', '.join(dropped)}, which run a different release: "
+            "the tool is missing there, or its arguments differ."
+        )
+
+    input_schema = dict(tool.get("inputSchema") or {})
+    properties = dict(input_schema.get("properties") or {})
+    properties[ENV_ARG] = {"type": "string", "enum": list(offered), "description": description}
+    input_schema["properties"] = properties
+    required = list(input_schema.get("required") or [])
+    if ENV_ARG not in required:
+        required.append(ENV_ARG)
+    input_schema["required"] = required
+
+    return {**tool, "inputSchema": input_schema}
+
+
+def merge_catalogs(
+    source: list[dict[str, Any]],
+    catalogues: Mapping[str, list[dict[str, Any]] | None],
+    environments: Sequence[EnvironmentSpec],
+) -> list[dict[str, Any]]:
+    """Publish `source`'s tools, splicing an `environment` enum into each one.
+
+    A tool offers an environment only when that environment's own copy of the
+    tool has an identical input-schema fingerprint, so a version-skewed
+    factory can never be handed argument shapes it does not accept.
+    """
+    reserved = [tool["name"] for tool in source if ENV_ARG in ((tool.get("inputSchema") or {}).get("properties") or {})]
+    if reserved:
+        raise CliError(
+            f'tool(s) {", ".join(reserved)} already declare an "{ENV_ARG}" argument, which the router reserves '
+            "to select the factory environment; rename it upstream or exclude the tool from --catalog."
+        )
+
+    merged = []
+    for tool in source:
+        reference = fingerprint(tool.get("inputSchema"))
+        offered = _offered_environments(tool["name"], reference, catalogues, environments)
+        merged.append(splice_environment(tool, offered, environments))
+    return merged
+
+
+def revalidate(
+    code: str,
+    remote: list[dict[str, Any]] | None,
+    *,
+    source: list[dict[str, Any]],
+    env_by_tool: Mapping[str, list[str]],
+) -> dict[str, list[str]]:
+    """Recompute `env_by_tool` after a previously-unreachable `code` answers.
+
+    `code` was offered on every tool by default (see `_offered_environments`)
+    since there was nothing to compare it against at startup. Now that its
+    real catalogue is in hand, drop it from any tool it turns out not to
+    offer, or offers with a different schema, so a later call is refused
+    without another round trip. Every other environment's entries are
+    returned unchanged.
+    """
+    remote_by_name = {tool.get("name"): tool for tool in (remote or [])}
+    updated = dict(env_by_tool)
+    for tool in source:
+        name = tool["name"]
+        offered = env_by_tool.get(name)
+        if offered is None or code not in offered:
+            continue
+        reference = fingerprint(tool.get("inputSchema"))
+        match = remote_by_name.get(name)
+        if match is None or fingerprint(match.get("inputSchema")) != reference:
+            updated[name] = [candidate for candidate in offered if candidate != code]
+    return updated

if_cli/router/policy.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+READ_ONLY_TOOLS = frozenset(
+    {
+        "tool_search",
+        "invoke_tool",
+        "find_production_lines",
+        "get_production_line",
+        "find_tasks",
+        "get_task",
+        "find_activities",
+        "get_task_config_schema",
+        "get_notebook",
+        "debug_production_line",
+        "debug_task",
+        "get_failed_tasks",
+        "run_sql_query",
+    }
+)
+
+READ_ONLY_PREFIXES = ("get_", "find_", "list_", "debug_")
+
+_MAX_INVOKE_TOOL_DEPTH = 8
+
+
+def _resolve_invoke_target(args: Mapping[str, Any], *, depth: int = 0) -> str | None:
+    """Descend through nested `invoke_tool` calls to find the real target.
+
+    `invoke_tool` is itself allowlisted, so
+    `invoke_tool(tool_name="invoke_tool", tool_input={"tool_name": "create_task", ...})`
+    hides its real, mutating target one level down in `tool_input`. Keep
+    unwrapping while the resolved name is still `invoke_tool`, capped so a
+    pathological chain cannot recurse unbounded.
+    """
+    if depth > _MAX_INVOKE_TOOL_DEPTH:
+        return None
+    tool_name = args.get("tool_name")
+    if not isinstance(tool_name, str) or not tool_name:
+        return None
+    if tool_name != "invoke_tool":
+        return tool_name
+    tool_input = args.get("tool_input")
+    if not isinstance(tool_input, Mapping):
+        return None
+    return _resolve_invoke_target(tool_input, depth=depth + 1)
+
+
+def blocked_write(
+    name: str,
+    args: Mapping[str, Any],
+    *,
+    code: str,
+    writable: bool,
+    extra_read_only: frozenset[str] = frozenset(),
+) -> str | None:
+    """The write gate, on a read-only environment: allow only tools known to read.
+
+    Deny by default rather than blocking a list of known writers. A model can
+    reach a tool outside the published catalogue through `invoke_tool`, so a
+    blocklist drawn from that catalogue could never cover what is actually
+    callable, and a mutating tool added upstream later would arrive permitted.
+    """
+    if writable:
+        return None
+
+    via = " (through invoke_tool)" if name == "invoke_tool" else ""
+    target = _resolve_invoke_target(args) if name == "invoke_tool" else name
+
+    if target is None:
+        return (
+            f'[{code}] could not determine what tool "{name}"{via} targets, so it is denied on {code}, '
+            f"which is configured read-only. Pass --allow-tool <name> or --writable {code}."
+        )
+
+    if target in READ_ONLY_TOOLS or target in extra_read_only:
+        return None
+    if any(target.startswith(prefix) for prefix in READ_ONLY_PREFIXES):
+        return None
+
+    return (
+        f'[{code}] "{target}"{via} is not a known read-only tool and {code} is configured read-only. '
+        f"Pass --allow-tool {target} or --writable {code}."
+    )

if_cli/router/server.py

@@ -0,0 +1,285 @@
+from __future__ import annotations
+
+import os
+import sys
+from dataclasses import dataclass
+from importlib.metadata import version
+from typing import Any
+
+import anyio
+import mcp_types as types
+from mcp.server import Server
+from mcp.server.context import ServerRequestContext
+from mcp.server.stdio import stdio_server
+
+from if_cli.config import Profile
+from if_cli.router import catalog, policy
+from if_cli.router.catalog import ENV_ARG, EnvironmentSpec
+from if_cli.router.upstream import Upstream
+from if_cli.runtime import CliError
+
+SERVER_NAME = "if-cli-mcp-router"
+SERVER_VERSION = version("insightfactory-cli")
+
+DEFAULT_CATALOG_RETRY_WINDOW_S = 5.0
+
+
+def log(message: str) -> None:
+    sys.stderr.write(f"[if-cli mcp] {message}\n")
+
+
+def _catalog_retry_window_seconds() -> float:
+    """Read the catalogue-rebuild retry window, in milliseconds, from the environment.
+
+    Not a documented `if-cli mcp` flag: this exists so tests can shrink the
+    window instead of sleeping out the real 5 seconds, mirroring
+    `if_cli.cache`'s `INSIGHTFACTORY_CACHE_LOCK_*` knobs.
+    """
+    raw = os.environ.get("INSIGHTFACTORY_MCP_CATALOG_RETRY_WINDOW_MS")
+    if raw is None:
+        return DEFAULT_CATALOG_RETRY_WINDOW_S
+    try:
+        value = float(raw)
+    except ValueError:
+        return DEFAULT_CATALOG_RETRY_WINDOW_S
+    return value / 1000.0 if value > 0 else DEFAULT_CATALOG_RETRY_WINDOW_S
+
+
+def _error_result(text: str) -> types.CallToolResult:
+    return types.CallToolResult(content=[types.TextContent(text=text)], is_error=True)
+
+
+@dataclass
+class RouterConfig:
+    environments: list[EnvironmentSpec]
+    catalog_source: str
+    extra_read_only: frozenset[str]
+
+
+class Router:
+    """Fronts several factory MCP endpoints as one server.
+
+    The catalogue comes from one environment (`config.catalog_source`) with an
+    `environment` enum spliced into every tool's input schema (see
+    `router.catalog`). A tool only offers an environment whose copy of that
+    tool has an identical input-schema fingerprint, so a version-skewed
+    factory can never be handed argument shapes it does not accept.
+    """
+
+    def __init__(
+        self,
+        config: RouterConfig,
+        upstreams: dict[str, Upstream],
+        *,
+        catalog_retry_window: float = DEFAULT_CATALOG_RETRY_WINDOW_S,
+    ) -> None:
+        self.config = config
+        self.upstreams = upstreams
+        self.tools: list[types.Tool] | None = None
+        self.env_by_tool: dict[str, list[str]] = {}
+        self.catalogues: dict[str, list[dict[str, Any]] | None] = {}
+        self.unverified: set[str] = set()
+        self._catalog_lock = anyio.Lock()
+        self._catalog_retry_window = catalog_retry_window
+        self._catalog_error: Exception | None = None
+        self._catalog_error_at: float = float("-inf")
+
+    def _label(self, code: str) -> str:
+        return next(env.label for env in self.config.environments if env.code == code)
+
+    async def _catalogues(self) -> dict[str, list[dict[str, Any]] | None]:
+        results: dict[str, list[dict[str, Any]] | None] = {}
+
+        async def fetch(code: str, upstream: Upstream) -> None:
+            try:
+                results[code] = await upstream.list_tools()
+            except Exception as error:
+                log(f"WARN {code} unreachable at startup: {error}")
+                results[code] = None
+
+        # Three environments can each hit get_valid_token's refresh path here
+        # concurrently; with_cache_lock (if_cli.cache) serialises the cache
+        # read-modify-write, so that race is safe by construction, not by luck.
+        async with anyio.create_task_group() as task_group:
+            for code, upstream in self.upstreams.items():
+                task_group.start_soon(fetch, code, upstream)
+        return results
+
+    async def build_catalog(self) -> list[types.Tool]:
+        """Build the merged catalogue. Safe to call again to pick up a new login."""
+        catalogues = await self._catalogues()
+        source = catalogues.get(self.config.catalog_source)
+        if source is None:
+            raise CliError(
+                f'catalog source "{self.config.catalog_source}" is unreachable, so there is no catalogue to '
+                f"publish. Log in with: if-cli login -p {self._label(self.config.catalog_source)}"
+            )
+
+        self.catalogues = catalogues
+        self.unverified = {code for code, remote in catalogues.items() if remote is None}
+        merged = catalog.merge_catalogs(source, catalogues, self.config.environments)
+        self.env_by_tool = {tool["name"]: tool["inputSchema"]["properties"][ENV_ARG]["enum"] for tool in merged}
+        tools = [types.Tool.model_validate(tool) for tool in merged]
+        self.tools = tools
+        log(f"catalogue: {len(tools)} tools from {self.config.catalog_source}")
+        return tools
+
+    async def prime_catalog(self) -> None:
+        """Build the catalogue in the background so `initialize` isn't held hostage.
+
+        Run as a task alongside `stdio_server`/`server.run` rather than before
+        them, so a hung factory reads as a slow tool list, not a failed
+        handshake. A failure here is already logged by `_ensure_catalog`; the
+        first real `list_tools`/`call_tool` request retries it (subject to the
+        retry window) instead of crashing the process mid-handshake.
+        """
+        try:
+            await self._ensure_catalog()
+        except Exception:
+            pass
+
+    async def _ensure_catalog(self) -> None:
+        """Build the catalogue on first use, and keep retrying on later failures.
+
+        A failed build (e.g. the catalog source has no cached token yet) is
+        not permanent: the next caller retries it, but no more often than
+        once per `_catalog_retry_window`, so a client polling `tools/list`
+        cannot hammer three factories while a login is still pending.
+        """
+        async with self._catalog_lock:
+            if self.tools is not None:
+                return
+            if self._catalog_error is not None:
+                if anyio.current_time() - self._catalog_error_at < self._catalog_retry_window:
+                    raise self._catalog_error
+            try:
+                await self.build_catalog()
+            except Exception as error:
+                log(f"catalogue build failed: {error}")
+                self._catalog_error = error
+                self._catalog_error_at = anyio.current_time()
+                raise
+            self._catalog_error = None
+
+    async def _revalidate(self, code: str, name: str) -> types.CallToolResult | None:
+        """Re-check a previously-unreachable environment before routing to it.
+
+        Returns an error result if the call should stop here (upstream still
+        unreachable, or it turns out not to offer `name`), or `None` to proceed.
+        """
+        try:
+            remote = await self.upstreams[code].list_tools()
+        except Exception as error:
+            message = str(error)
+            return _error_result(message if message.startswith(f"[{code}]") else f"[{code}] {message}")
+
+        self.catalogues[code] = remote
+        self.unverified.discard(code)
+        source = self.catalogues.get(self.config.catalog_source) or []
+        self.env_by_tool = catalog.revalidate(code, remote, source=source, env_by_tool=self.env_by_tool)
+        # Only tools the router actually publishes are subject to the offer
+        # check; a name reached directly (e.g. through invoke_tool) that was
+        # never part of the merged catalogue is forwarded unconditionally,
+        # exactly as it already is on an environment that was verified from
+        # the start (see the plain `self.env_by_tool.get(name)` check below).
+        if name in self.env_by_tool and code not in self.env_by_tool[name]:
+            return _error_result(f'[{code}] does not offer "{name}" (missing there, or its arguments differ).')
+        return None
+
+    async def list_tools(self) -> list[types.Tool]:
+        await self._ensure_catalog()
+        assert self.tools is not None
+        return self.tools
+
+    async def call_tool(self, name: str, raw_arguments: dict[str, Any] | None) -> types.CallToolResult:
+        try:
+            await self._ensure_catalog()
+        except Exception as error:
+            return _error_result(str(error))
+
+        args = dict(raw_arguments or {})
+        code = args.pop(ENV_ARG, None)
+        if not code:
+            return _error_result(f'"{ENV_ARG}" is required. Choose one of: {", ".join(self.upstreams)}')
+        if code not in self.upstreams:
+            return _error_result(f'Unknown environment "{code}". Choose one of: {", ".join(self.upstreams)}')
+
+        # The write gate runs before anything that could touch the network
+        # (the offer check below is local; revalidation is not) so a refused
+        # write to an unverified environment never sends it a single request.
+        environment = next(env for env in self.config.environments if env.code == code)
+        blocked = policy.blocked_write(
+            name, args, code=code, writable=environment.writable, extra_read_only=self.config.extra_read_only
+        )
+        if blocked:
+            return _error_result(blocked)
+
+        offered = self.env_by_tool.get(name)
+        if offered is not None and code not in offered:
+            return _error_result(f'[{code}] does not offer "{name}" (missing there, or its arguments differ).')
+
+        if code in self.unverified:
+            revalidation_error = await self._revalidate(code, name)
+            if revalidation_error is not None:
+                return revalidation_error
+
+        try:
+            return await self.upstreams[code].call_tool(name, args)
+        except Exception as error:
+            # Prefix so a per-environment permission failure never reads as a router bug.
+            message = str(error)
+            return _error_result(message if message.startswith(f"[{code}]") else f"[{code}] {message}")
+
+
+def build_router(
+    *,
+    profiles: dict[str, Profile],
+    writable_codes: frozenset[str],
+    catalog_source: str,
+    extra_read_only: frozenset[str],
+    timeout: float,
+) -> Router:
+    environments = [
+        EnvironmentSpec(code=code, label=profile["name"], writable=code in writable_codes)
+        for code, profile in profiles.items()
+    ]
+    upstreams = {code: Upstream(code, profile, timeout=timeout) for code, profile in profiles.items()}
+    config = RouterConfig(environments=environments, catalog_source=catalog_source, extra_read_only=extra_read_only)
+    return Router(config, upstreams, catalog_retry_window=_catalog_retry_window_seconds())
+
+
+async def _on_list_tools(
+    router: Router, _ctx: ServerRequestContext[Any], _params: types.PaginatedRequestParams | None
+) -> types.ListToolsResult:
+    return types.ListToolsResult(tools=await router.list_tools())
+
+
+async def _on_call_tool(
+    router: Router, _ctx: ServerRequestContext[Any], params: types.CallToolRequestParams
+) -> types.CallToolResult:
+    return await router.call_tool(params.name, params.arguments)
+
+
+async def _serve(router: Router) -> None:
+    server: Server[Any] = Server(
+        SERVER_NAME,
+        version=SERVER_VERSION,
+        on_list_tools=lambda ctx, params: _on_list_tools(router, ctx, params),
+        on_call_tool=lambda ctx, params: _on_call_tool(router, ctx, params),
+    )
+    # Answer `initialize` immediately: the catalogue build runs as a background
+    # task so one hung factory reads as a slow tools/list, not a failed
+    # handshake (clients cap startup time).
+    async with stdio_server() as (read_stream, write_stream):
+        log("ready over stdio")
+        async with anyio.create_task_group() as task_group:
+            task_group.start_soon(router.prime_catalog)
+            await server.run(read_stream, write_stream, server.create_initialization_options())
+            # stdin EOF means the client is gone: don't make shutdown wait for
+            # a still-running catalogue build (up to --timeout) when nothing
+            # will ever read its result.
+            task_group.cancel_scope.cancel()
+
+
+def run_server(router: Router) -> None:
+    anyio.run(_serve, router)

if_cli/router/upstream.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import sys
+from typing import Any
+
+import anyio
+import httpx2
+import mcp_types as types
+from mcp.client import Client
+from mcp.client.streamable_http import streamable_http_client
+
+from if_cli.config import Profile
+from if_cli.http import parse_url, url_origin
+from if_cli.oauth import get_valid_token
+
+if sys.version_info >= (3, 11):
+    _BaseExceptionGroup = BaseExceptionGroup  # noqa: F821 - builtin from 3.11 on, guarded above
+else:  # pragma: no cover - exercised only on Python < 3.11
+    # anyio pulls in this backport for exactly that case, so it is always
+    # importable here when the builtin is not.
+    from exceptiongroup import BaseExceptionGroup as _BaseExceptionGroup  # ty: ignore[unresolved-import]
+
+
+def _leaf_exception(error: BaseException) -> BaseException:
+    """Unwrap nested single-member `BaseExceptionGroup`s down to their real cause.
+
+    anyio/httpx2 run request handling in task groups, so a failure inside
+    `ProfileBearerAuth` (e.g. the `CliError` login hint from `get_valid_token`)
+    reaches the caller wrapped in one or more `BaseExceptionGroup`s, and a plain
+    `str(error)` on those prints "unhandled errors in a TaskGroup" instead of the
+    real message. A group with several leaves has no single real cause, so those
+    are joined instead of picked from.
+    """
+    if isinstance(error, _BaseExceptionGroup):
+        leaves = [_leaf_exception(sub) for sub in error.exceptions]
+        if len(leaves) == 1:
+            return leaves[0]
+        return RuntimeError("; ".join(str(leaf) for leaf in leaves))
+    return error
+
+
+class ProfileBearerAuth(httpx2.Auth):
+    """Injects a fresh `if-cli` bearer token per request; re-mints once on a 401.
+
+    Never sends a profile's token to any origin but its own factory host —
+    the rule from AGENTS.md, made mechanical.
+    """
+
+    def __init__(self, profile: Profile) -> None:
+        self._profile = profile
+
+    async def async_auth_flow(self, request: httpx2.Request):  # noqa: ANN201 - httpx2.Auth's own generator protocol
+        origin = url_origin(parse_url(str(request.url)))
+        if origin != self._profile["host"]:
+            raise RuntimeError(
+                f"refusing to send the '{self._profile['name']}' profile's bearer token to {origin}; "
+                f"its factory origin is {self._profile['host']}"
+            )
+        token = await anyio.to_thread.run_sync(get_valid_token, self._profile)
+        request.headers["Authorization"] = f"Bearer {token}"
+        response = yield request
+        if response.status_code == 401:
+            token = await anyio.to_thread.run_sync(lambda: get_valid_token(self._profile, force_refresh=True))
+            request.headers["Authorization"] = f"Bearer {token}"
+            yield request
+
+
+class Upstream:
+    """One factory environment's `/mcp` endpoint, reached with its own `if-cli` profile.
+
+    The factory's streamable-HTTP transport is stateless, so every call opens
+    its own client session (connect, initialize, call, close) instead of
+    holding a long-lived connection open for the process lifetime. That keeps
+    this class small and avoids babysitting three persistent connections.
+    """
+
+    def __init__(self, code: str, profile: Profile, *, timeout: float) -> None:
+        self.code = code
+        self.profile = profile
+        self.timeout = timeout
+
+    async def _run(self, action):
+        url = f"{self.profile['host']}/mcp"
+        try:
+            async with httpx2.AsyncClient(auth=ProfileBearerAuth(self.profile), timeout=self.timeout) as http_client:
+                async with Client(streamable_http_client(url, http_client=http_client)) as client:
+                    return await action(client)
+        except _BaseExceptionGroup as error:
+            raise _leaf_exception(error) from error
+
+    async def list_tools(self) -> list[dict[str, Any]]:
+        async def collect(client: Client) -> list[dict[str, Any]]:
+            collected: list[dict[str, Any]] = []
+            cursor: str | None = None
+            while True:
+                result = await client.list_tools(cursor=cursor)
+                collected.extend(
+                    tool.model_dump(by_alias=True, mode="json", exclude_unset=True) for tool in result.tools
+                )
+                if not result.next_cursor:
+                    return collected
+                cursor = result.next_cursor
+
+        return await self._run(collect)
+
+    async def call_tool(self, name: str, arguments: dict[str, Any]) -> types.CallToolResult:
+        return await self._run(lambda client: client.call_tool(name, arguments))

{insightfactory_cli-1.0.2.dev16.dist-info → insightfactory_cli-1.0.3.dev19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: insightfactory-cli
-Version: 1.0.2.dev16
+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>
@@ -14,6 +14,12 @@ 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
@@ -201,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.
@@ -219,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
@@ -236,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.2.dev16.dist-info → insightfactory_cli-1.0.3.dev19.dist-info}/RECORD

@@ -1,24 +1,30 @@
 if_cli/__init__.py,sha256=YYcz-hEiXXUjdBFGipOrVHynsyH4ZLqQOCDobvCAu8Y,26
 if_cli/__main__.py,sha256=2hLFIiT-gocMb0VJVzVYtGVIoHrxyMChucRgexbXLSQ,68
 if_cli/cache.py,sha256=UfvHs3GQIVg0sVfKYWw4UGlq8d-8BEXuZIDfC1hwwjA,6587
-if_cli/cli.py,sha256=1pdYz3bhsNO120aWs9Fqjchj4UvNByn5Otk62IiBvzY,5832
+if_cli/cli.py,sha256=fF7HvsUgpKhkLFdXLMJ1JXHGjp3RwJt2YmPSEW0d8gY,6270
 if_cli/colour.py,sha256=2hbaM4ubTHGja6YZRD886eqnB7T2IaZyW5rvfOjxe4M,682
-if_cli/config.py,sha256=IZhuo0cMsP-L9rLIKYVB87YRhCF-tcuyBTWp0-um4vM,6338
+if_cli/config.py,sha256=YFnegm_-e051bL0vyTFIkVrKamjgY08DVCqK0VgFNvA,10129
 if_cli/constants.py,sha256=RW43KupAdhXfBsX6MxzZdJ-R57brX0q0TgIq8xXgvPs,269
 if_cli/http.py,sha256=W8HL3uZLeOu5MgmsOavM1Y6x4AcrInIQsAr5hx-j8AE,7671
-if_cli/main.py,sha256=kkJVfkRHvdcMLysmfsag7YVneDpJP02I0KRVdOaBh3k,2697
-if_cli/oauth.py,sha256=X0514sPBysjGwcN5_39KaQfQ62sbl72Xztixd9BqOE4,16076
+if_cli/main.py,sha256=pn-X2wrHNplc8ceT5_nEv5XlrTN3KgpK8UU4gAmBiWY,3212
+if_cli/oauth.py,sha256=8hlTj8k01jXWtx_D5RrwSKamYJE9CD7DDwq4Dqc28MU,16535
 if_cli/runtime.py,sha256=Pz2iVclqy-uu1UMQWK2P_Hx7O4zAF30UpSFqQvGN0NY,2663
 if_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 if_cli/commands/api.py,sha256=XeVhhD39Oho4xNbMJIGh1I6vi53on5EGGsAtsb_5TAg,9016
 if_cli/commands/config.py,sha256=1KAxjme897NIbXTGBw1rNJlXnFvhbEUf5MAli8A93ns,1724
 if_cli/commands/login.py,sha256=vxsYcRZWsaNEzekyN1zy4ROJO-OCGUpjaVUBhtbK1LY,3255
 if_cli/commands/logout.py,sha256=TW0P4_tXcTtiHHR73xVPHyhlbOWD1jBnkZsMImCiCBw,668
-if_cli/commands/profiles.py,sha256=JNBrYWdHQ9MHauwZxH33IAOYgRYRniX7bwd7KBT6Vyk,3869
+if_cli/commands/mcp.py,sha256=nXc6qT-psryLDm8Yjmu_2IFDOEnNIAjCkCT5UTDZP4M,6553
+if_cli/commands/profiles.py,sha256=tgZP5sMqzbFHXlfvglL2plsGdU0M3joo3wvQKX45J1U,3950
 if_cli/commands/set_token.py,sha256=BVyv_QmByvllr04pE2sz8JFEscHbIgOC-7ZPg61PRoc,1886
 if_cli/commands/token.py,sha256=CyiXkyH7vxgH91-n-XJzeHnLI6mZJwO9Js5AHvfHaeM,1120
-insightfactory_cli-1.0.2.dev16.dist-info/METADATA,sha256=Iq2H3FJKYrsSgrIHMnaXt1Nl4FuJUGv53lXQ0iTPTb0,13101
-insightfactory_cli-1.0.2.dev16.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-insightfactory_cli-1.0.2.dev16.dist-info/entry_points.txt,sha256=UlX854D7f-7dBj5F0wGdakVy6vopvP9hA1BN-gv739w,44
-insightfactory_cli-1.0.2.dev16.dist-info/licenses/LICENSE,sha256=8eZ1YAABL398qESVJc_FlK1voYQ0GAh-R_rNBQK6QH8,234
-insightfactory_cli-1.0.2.dev16.dist-info/RECORD,,
+if_cli/router/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+if_cli/router/catalog.py,sha256=Er2ZbWTwDUVU-qBGCvyA0bIlFk3UYw_6sVUlYwBhMpI,4992
+if_cli/router/policy.py,sha256=CclbjuOA5mwwoQiNDa17iQeN9eXRbfy11bS9JFd8gL4,2840
+if_cli/router/server.py,sha256=kTQwvUVyco8QjOfjPHZF8LYUmHi8R5DdIk-Wxr5yHVA,12176
+if_cli/router/upstream.py,sha256=qFWSQ0lDTXM_8Q7vq8X5sWP2cMWXx5Hn-WwiLL7r3UM,4631
+insightfactory_cli-1.0.3.dev19.dist-info/METADATA,sha256=Q_3o-4eDdISScq_WWPvTq3oL93cGxIYJMJ1DDi4Ueqw,17509
+insightfactory_cli-1.0.3.dev19.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+insightfactory_cli-1.0.3.dev19.dist-info/entry_points.txt,sha256=UlX854D7f-7dBj5F0wGdakVy6vopvP9hA1BN-gv739w,44
+insightfactory_cli-1.0.3.dev19.dist-info/licenses/LICENSE,sha256=8eZ1YAABL398qESVJc_FlK1voYQ0GAh-R_rNBQK6QH8,234
+insightfactory_cli-1.0.3.dev19.dist-info/RECORD,,