insightfactory-cli 1.2.0.dev34__py3-none-any.whl → 1.3.0.dev39__py3-none-any.whl

if_cli/cache.py

@@ -1,20 +1,25 @@
 from __future__ import annotations
 
+import hashlib
 import json
 import math
 import os
 import time
 from collections.abc import Callable
-from typing import TypedDict, TypeGuard, TypeVar
+from typing import NoReturn, TypedDict, TypeGuard, TypeVar
 
-from if_cli.config import cache_file, write_private_file
+from if_cli.config import cache_file, get_profile, is_factory_section, load_config, write_private_file
 from if_cli.constants import EXPIRY_SLACK_SECONDS
 from if_cli.runtime import die, is_record
 
 CACHE_LOCK_STALE_MS = 30_000
+CACHE_VERSION = 2
+HOST_KEYED_CACHE_VERSION = 1
 
 
 class CacheEntry(TypedDict, total=False):
+    host: str
+    grant: str
     access_token: str
     refresh_token: str
     expires_at: float
@@ -23,10 +28,53 @@ class CacheEntry(TypedDict, total=False):
 
 
 class TokenCache(TypedDict):
+    """Version 2 keys `tokens` by profile name. Each entry records the host it was
+    issued for, and is used only while the profile still points at that host."""
+
     version: int
     tokens: dict[str, CacheEntry]
 
 
+class TokenOwner(TypedDict):
+    """The part of a `Profile` that owns a cache entry."""
+
+    name: str
+    host: str
+
+
+def empty_cache() -> TokenCache:
+    return {"version": CACHE_VERSION, "tokens": {}}
+
+
+def entry_for(cache: TokenCache, owner: TokenOwner) -> CacheEntry | None:
+    """The profile's entry, unless it was issued for a host the profile no longer
+    names: a bearer token never goes to an origin other than the one it came from."""
+    entry = cache["tokens"].get(owner["name"])
+    if entry is None or entry.get("host") != owner["host"]:
+        return None
+    return entry
+
+
+def _siblings(cache: TokenCache, owner: TokenOwner, grant: str | None) -> list[str]:
+    """Other profiles on the same host that share the owner's `grant`.
+
+    Only a version 1 cache produces these: it held one entry per host, which the
+    upgrade copies to every profile on that host, marking the copies with one
+    `grant` id. They are one sign-in, so a rotation or rejection on one applies to
+    all of them; leaving a sibling on the rotated-out refresh token would replay it
+    on its next refresh. The id outlives a cleared refresh token, so a refresh that
+    lands after a peer's invalid_grant still reaches every sibling. A login or a
+    pasted token starts a fresh entry without it, which ends the sharing.
+    """
+    if not grant:
+        return []
+    return [
+        name
+        for name, entry in cache["tokens"].items()
+        if name != owner["name"] and entry.get("host") == owner["host"] and entry.get("grant") == grant
+    ]
+
+
 def _positive_integer_env(name: str, fallback: int) -> int:
     raw = os.environ.get(name)
     if raw is None:
@@ -58,9 +106,13 @@ def is_fresh(entry: CacheEntry, now_seconds: float | None = None) -> bool:
     return entry["expires_at"] - EXPIRY_SLACK_SECONDS > now_seconds
 
 
-def _is_cache_entry(value: object) -> TypeGuard[CacheEntry]:
+def _is_cache_entry(value: object, *, with_host: bool) -> TypeGuard[CacheEntry]:
     if not is_record(value):
         return False
+    if with_host and not isinstance(value.get("host"), str):
+        return False
+    if "grant" in value and not isinstance(value.get("grant"), str):
+        return False
     access_token = value.get("access_token")
     expires_at = value.get("expires_at")
     token_endpoint = value.get("token_endpoint")
@@ -77,19 +129,67 @@ def _is_cache_entry(value: object) -> TypeGuard[CacheEntry]:
     )
 
 
+def _invalid_structure() -> NoReturn:
+    die(f"token cache {cache_file()} has an invalid structure; move it aside and log in again")
+
+
+def _parse_entries(tokens_value: dict[str, object], *, with_host: bool) -> dict[str, CacheEntry]:
+    tokens: dict[str, CacheEntry] = {}
+    for key, entry in tokens_value.items():
+        if not _is_cache_entry(entry, with_host=with_host):
+            die(f"token cache entry for {key} is invalid; move {cache_file()} aside and log in again")
+        tokens[key] = entry
+    return tokens
+
+
+def _from_host_keyed(tokens_by_host: dict[str, CacheEntry]) -> dict[str, CacheEntry]:
+    """Give each configured profile the version 1 entry for its host.
+
+    A host entry with no profile left on that host is unreachable, so it is
+    dropped. A profile that does not resolve gets nothing, as it could not have
+    used a token before either.
+    """
+    config = load_config()
+    tokens: dict[str, CacheEntry] = {}
+    for section in config:
+        if is_factory_section(section):
+            continue
+        name = "DEFAULT" if section == "" else section
+        try:
+            host = get_profile(config, name)["host"]
+        except Exception:
+            # Not only CliError: a bad port raises ValueError or OverflowError. One
+            # broken profile must not stop every other profile's cache read.
+            continue
+        entry = tokens_by_host.get(host)
+        if entry is not None:
+            migrated = entry.copy()
+            migrated["host"] = host
+            tokens[name] = migrated
+    hosts = [entry["host"] for entry in tokens.values()]
+    for entry in tokens.values():
+        refresh_token = entry.get("refresh_token")
+        if refresh_token and hosts.count(entry["host"]) > 1:
+            # Derived, not random: every process reading the same version 1 file
+            # agrees on it until the first write saves version 2.
+            entry["grant"] = hashlib.sha256(f"{entry['host']}\n{refresh_token}".encode()).hexdigest()[:32]
+    return tokens
+
+
 def _parse_cache(raw: str) -> TokenCache:
     value: object = json.loads(raw)
     if not is_record(value):
-        die(f"token cache {cache_file()} has an invalid structure; move it aside and log in again")
+        _invalid_structure()
     tokens_value = value.get("tokens")
-    if value.get("version") != 1 or not is_record(tokens_value):
-        die(f"token cache {cache_file()} has an invalid structure; move it aside and log in again")
-    tokens: dict[str, CacheEntry] = {}
-    for host, entry in tokens_value.items():
-        if not _is_cache_entry(entry):
-            die(f"token cache entry for {host} is invalid; move {cache_file()} aside and log in again")
-        tokens[host] = entry
-    return {"version": 1, "tokens": tokens}
+    if not is_record(tokens_value):
+        _invalid_structure()
+    version = value.get("version")
+    if version == CACHE_VERSION:
+        return {"version": CACHE_VERSION, "tokens": _parse_entries(tokens_value, with_host=True)}
+    if version == HOST_KEYED_CACHE_VERSION:
+        tokens_by_host = _parse_entries(tokens_value, with_host=False)
+        return {"version": CACHE_VERSION, "tokens": _from_host_keyed(tokens_by_host)}
+    _invalid_structure()
 
 
 def load_cache() -> TokenCache:
@@ -97,7 +197,7 @@ def load_cache() -> TokenCache:
         with open(cache_file(), encoding="utf-8") as handle:
             return _parse_cache(handle.read())
     except FileNotFoundError:
-        return {"version": 1, "tokens": {}}
+        return empty_cache()
     except json.JSONDecodeError:
         die(f"token cache {cache_file()} is not valid JSON; move it aside and log in again")
 
@@ -138,24 +238,29 @@ def with_cache_lock(operation: Callable[[], T]) -> T:
     die(f"timed out waiting for token cache lock {lock_file}")
 
 
-def clear_token(host: str) -> bool:
+def clear_token(owner: TokenOwner) -> bool:
+    """Remove the profile's entry, whichever host it was issued for."""
+
     def operation() -> bool:
         cache = load_cache()
-        if host not in cache["tokens"]:
+        if owner["name"] not in cache["tokens"]:
             return False
-        del cache["tokens"][host]
+        del cache["tokens"][owner["name"]]
         _save_cache(cache)
         return True
 
     return with_cache_lock(operation)
 
 
-def clear_refresh_token_if_matches(host: str, rejected_token: str) -> bool:
+def clear_refresh_token_if_matches(owner: TokenOwner, rejected_token: str) -> bool:
     def operation() -> bool:
         cache = load_cache()
-        entry = cache["tokens"].get(host)
+        entry = entry_for(cache, owner)
         if not entry or entry.get("refresh_token") != rejected_token:
             return False
+        for name in _siblings(cache, owner, entry.get("grant")):
+            if cache["tokens"][name].get("refresh_token") == rejected_token:
+                cache["tokens"][name].pop("refresh_token", None)
         entry.pop("refresh_token", None)
         _save_cache(cache)
         return True
@@ -164,16 +269,19 @@ def clear_refresh_token_if_matches(host: str, rejected_token: str) -> bool:
 
 
 def store_tokens(
-    host: str,
+    owner: TokenOwner,
     token_response: dict[str, object],
     token_endpoint: str,
     client_id: str | None = None,
     *,
     replace: bool = False,
 ) -> CacheEntry:
+    """Write the profile's entry. `replace` starts it afresh (a login or a pasted
+    token); otherwise it updates the entry in place (a refresh)."""
+
     def operation() -> CacheEntry:
         cache = load_cache()
-        previous = None if replace else cache["tokens"].get(host)
+        previous = None if replace else entry_for(cache, owner)
         expires_in_raw = token_response.get("expires_in")
         if (
             isinstance(expires_in_raw, bool)
@@ -187,6 +295,7 @@ def store_tokens(
         access_token = token_response.get("access_token")
         if not isinstance(access_token, str):
             die("token response did not include a valid access token")
+        entry["host"] = owner["host"]
         entry["access_token"] = access_token
         entry["expires_at"] = int(math.floor(time.time()) + expires_in)
         entry["token_endpoint"] = token_endpoint
@@ -199,7 +308,10 @@ def store_tokens(
             entry["refresh_token"] = refresh_token
         elif replace:
             entry.pop("refresh_token", None)
-        cache["tokens"][host] = entry
+        if previous is not None:
+            for name in _siblings(cache, owner, previous.get("grant")):
+                cache["tokens"][name] = entry.copy()
+        cache["tokens"][owner["name"]] = entry
         _save_cache(cache)
         return entry
 

if_cli/commands/logout.py

@@ -14,7 +14,6 @@ LOGOUT_OPTIONS: Options = {
 def logout_command(argv: list[str]) -> None:
     values, _positionals = parse_args(argv, options=LOGOUT_OPTIONS)
     profile = get_profile(load_config(), resolve_profile_name(values["profile"]))
-    removed = clear_token(profile["host"])
-    sys.stdout.write(
-        f"✓ cleared cached token for {profile['host']}\n" if removed else f"no cached token for {profile['host']}\n"
-    )
+    removed = clear_token(profile)
+    target = f"profile '{profile['name']}' ({profile['host']})"
+    sys.stdout.write(f"✓ cleared cached token for {target}\n" if removed else f"no cached token for {target}\n")

if_cli/commands/profiles.py

@@ -5,7 +5,7 @@ import sys
 import time
 from typing import Literal, TypedDict
 
-from if_cli.cache import TokenCache, is_fresh, load_cache
+from if_cli.cache import TokenCache, empty_cache, entry_for, 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, is_factory_section, load_config
@@ -57,7 +57,7 @@ def summarize_profiles(
             )
             continue
 
-        entry = cache["tokens"].get(profile["host"])
+        entry = entry_for(cache, profile)
         token: ProfileTokenSummary
         if cache_error:
             token = {"status": "unknown", "error": cache_error}
@@ -99,7 +99,7 @@ def profiles_command(argv: list[str] | None = None) -> None:
         sys.stdout.write(f"no profiles configured in {config_file()}\n")
         return
 
-    cache: TokenCache = {"version": 1, "tokens": {}}
+    cache: TokenCache = empty_cache()
     cache_error: str | None = None
     try:
         cache = load_cache()

if_cli/commands/set_token.py

@@ -48,7 +48,7 @@ def set_token_command(argv: list[str]) -> None:
     if expiry is not None and expiry <= now:
         die("the provided access token is already expired")
     entry = store_tokens(
-        profile["host"],
+        profile,
         {
             "access_token": token,
             "expires_in": 3600 if expiry is None else expiry - now,

if_cli/oauth.py

@@ -14,6 +14,7 @@ from urllib.parse import parse_qsl, urlencode, urlparse, urlunparse
 from if_cli.cache import (
     CacheEntry,
     clear_refresh_token_if_matches,
+    entry_for,
     is_fresh,
     load_cache,
     store_tokens,
@@ -334,10 +335,10 @@ def login(profile: Profile, no_browser: bool, options: dict[str, str] | None = N
             "redirect_uri": redirect_uri,
         },
     )
-    return store_tokens(profile["host"], tokens, metadata["token_endpoint"], client_id, replace=True)
+    return store_tokens(profile, tokens, metadata["token_endpoint"], client_id, replace=True)
 
 
-def _refresh(host: str, entry: CacheEntry, refresh_token: str, client_id: str) -> CacheEntry:
+def _refresh(profile: Profile, entry: CacheEntry, refresh_token: str, client_id: str) -> CacheEntry:
     tokens = _token_request(
         entry["token_endpoint"],
         {
@@ -346,12 +347,12 @@ def _refresh(host: str, entry: CacheEntry, refresh_token: str, client_id: str) -
             "refresh_token": refresh_token,
         },
     )
-    return store_tokens(host, tokens, entry["token_endpoint"], client_id)
+    return store_tokens(profile, tokens, entry["token_endpoint"], client_id)
 
 
-def _wait_for_fresh_token(host: str, *, exclude: str | None = None) -> str | None:
+def _wait_for_fresh_token(profile: Profile, *, exclude: str | None = None) -> str | None:
     for attempt in range(RECOVERY_POLL_ATTEMPTS):
-        entry = load_cache()["tokens"].get(host)
+        entry = entry_for(load_cache(), profile)
         if entry and is_fresh(entry) and entry["access_token"] != exclude:
             return entry["access_token"]
         if attempt + 1 < RECOVERY_POLL_ATTEMPTS:
@@ -360,7 +361,7 @@ def _wait_for_fresh_token(host: str, *, exclude: str | None = None) -> str | Non
 
 
 def get_valid_token(profile: Profile, *, force_refresh: bool = False) -> str:
-    entry = load_cache()["tokens"].get(profile["host"])
+    entry = entry_for(load_cache(), profile)
     if not entry:
         die(f"no cached token for {profile['host']} — run: if-cli login -p {profile['name']}")
     if not force_refresh and is_fresh(entry):
@@ -374,32 +375,30 @@ def get_valid_token(profile: Profile, *, force_refresh: bool = False) -> str:
     if refresh_token:
         client_id = entry.get("client_id")
         if not client_id:
-            clear_refresh_token_if_matches(profile["host"], refresh_token)
+            clear_refresh_token_if_matches(profile, refresh_token)
             die(
                 f"could not refresh token for {profile['host']}: no client id cached — "
                 f"run: if-cli login -p {profile['name']}"
             )
         try:
-            return _refresh(profile["host"], entry, refresh_token, client_id)["access_token"]
+            return _refresh(profile, entry, refresh_token, client_id)["access_token"]
         except Exception as error:
             failure: BaseException = error
             if isinstance(error, TokenRequestError) and error.invalidates_refresh_token:
-                cleared = clear_refresh_token_if_matches(profile["host"], refresh_token)
+                cleared = clear_refresh_token_if_matches(profile, refresh_token)
                 if cleared:
                     recovered_access_token = _wait_for_fresh_token(
-                        profile["host"], exclude=entry["access_token"] if force_refresh else None
+                        profile, exclude=entry["access_token"] if force_refresh else None
                     )
                     if recovered_access_token:
                         return recovered_access_token
                 else:
-                    recovered = load_cache()["tokens"].get(profile["host"])
+                    recovered = entry_for(load_cache(), profile)
                     recovered_refresh = recovered.get("refresh_token") if recovered else None
                     recovered_client_id = recovered.get("client_id") if recovered else None
                     if recovered and recovered_refresh and recovered_refresh != refresh_token and recovered_client_id:
                         try:
-                            return _refresh(profile["host"], recovered, recovered_refresh, recovered_client_id)[
-                                "access_token"
-                            ]
+                            return _refresh(profile, recovered, recovered_refresh, recovered_client_id)["access_token"]
                         except Exception as retry_error:
                             failure = retry_error
             detail = f": {failure}" if isinstance(failure, Exception) else ""

{insightfactory_cli-1.2.0.dev34.dist-info → insightfactory_cli-1.3.0.dev39.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: insightfactory-cli
-Version: 1.2.0.dev34
+Version: 1.3.0.dev39
 Summary: Profile-based authentication CLI for the InsightFactory Interfaces API
 Project-URL: Homepage, https://insightfactory.ai
 Author-email: "insightfactory.ai Support" <support@insightfactory.ai>
@@ -27,9 +27,9 @@ Description-Content-Type: text/markdown
 Profile-based authentication CLI for the InsightFactory Interfaces API. It
 installs the `if-cli` command, which logs in through the browser with OAuth
 authorization code and PKCE, refreshes tokens, and makes authenticated API
-calls. Profiles live in `~/.insightfactory` in the same layout the Node
-`@insightfactory-ai/if-cli` uses, so both implementations can share one config
-directory.
+calls. Profiles live in `~/.insightfactory` in the same layout the retired Node
+`@insightfactory-ai/if-cli` used. The token cache uses its own format, described
+under "How authentication works".
 
 This is the production Python CLI, published to public PyPI. It needs Python
 3.10 or newer.
@@ -229,8 +229,20 @@ rejected.
 - Profiles live in `~/.insightfactory/config`, one per customer and environment.
 - The CLI manages the profile file and regenerates it on updates. Comments and
   empty sections are not preserved.
-- Tokens are cached by host in `~/.insightfactory/token-cache.json` with file
-  mode `0600`.
+- Tokens are cached per profile in `~/.insightfactory/token-cache.json` with
+  file mode `0600`. Two profiles on the same host can sign in as different
+  accounts, and each keeps its own token. Each entry records the host that
+  issued it, and a profile uses it only while its `host` still matches, so a
+  token never goes to another origin after a host change.
+- `if-cli` 1.3.0 and later write version 2 of the cache, keyed by profile
+  name. They read the older version 1 cache, keyed by host, and give its token
+  to every profile on that host, so an upgrade needs no new login. Older
+  `if-cli` releases and the Node CLI cannot read version 2 and stop on every
+  command, `login` included. To downgrade, move `token-cache.json` aside, then
+  sign in to each profile again.
+- A version 1 cache holds one account per host. If two profiles on one host
+  signed in as different accounts before 1.3.0, both start out as whichever
+  account signed in last. Run `if-cli login -p <profile>` once for each of them.
 - The configuration directory is `0700`. Configuration and cache updates are
   atomic.
 - Remote factory, authorization, and token endpoints must use HTTPS. HTTP is
@@ -512,9 +524,12 @@ differ:
 - **`--version`** reads the installed package metadata from `1.0.0` onward
   rather than an npm `package.json`.
 
-On-disk profile and token-cache paths, JSON shapes, and file permissions stay
-compatible with the Node CLI, so you can switch implementations without
-re-authenticating.
+On-disk profile and token-cache paths and file permissions match the Node CLI.
+The token cache's JSON shape does not: `if-cli` keys it by profile (version 2),
+which the Node CLI and older `if-cli` releases cannot read. The Python CLI
+still reads a Node-written version 1 cache, so moving from Node to Python needs
+no new login. To move back, move `token-cache.json` aside and sign in to each
+profile again.
 
 ## Licence
 

{insightfactory_cli-1.2.0.dev34.dist-info → insightfactory_cli-1.3.0.dev39.dist-info}/RECORD

@@ -1,7 +1,7 @@
 if_cli/__init__.py,sha256=YYcz-hEiXXUjdBFGipOrVHynsyH4ZLqQOCDobvCAu8Y,26
 if_cli/__main__.py,sha256=2hLFIiT-gocMb0VJVzVYtGVIoHrxyMChucRgexbXLSQ,68
 if_cli/attribution.py,sha256=hNp1hBueRUh1EKYs61AZF76voehw70F7gZKiI5zOMCw,1869
-if_cli/cache.py,sha256=UfvHs3GQIVg0sVfKYWw4UGlq8d-8BEXuZIDfC1hwwjA,6587
+if_cli/cache.py,sha256=-jEr2t50_dRQ7ZBorbOVyqEkwDdWZOgbNoPHAW5yHPU,11240
 if_cli/callback_page.py,sha256=lTHd3-vzlT9ndAL7XYonBfy97lBW7apRw3V7SmhNObo,5907
 if_cli/cli.py,sha256=fF7HvsUgpKhkLFdXLMJ1JXHGjp3RwJt2YmPSEW0d8gY,6270
 if_cli/colour.py,sha256=2hbaM4ubTHGja6YZRD886eqnB7T2IaZyW5rvfOjxe4M,682
@@ -9,7 +9,7 @@ if_cli/config.py,sha256=QiphIhVLDN3sp39xMWKwXEyJWxx4IhXT28oEtmPc0ew,10601
 if_cli/constants.py,sha256=WxZozWfhMCFWU_Wupa__CaJI9UgqJ28W8cchGtp6p4Q,303
 if_cli/http.py,sha256=LNkQtyUR1DAgLcR2CrNzTMHFQO_j_vfHuOBagmQEYNk,8249
 if_cli/main.py,sha256=pn-X2wrHNplc8ceT5_nEv5XlrTN3KgpK8UU4gAmBiWY,3212
-if_cli/oauth.py,sha256=lSJXzOsOzHlkZX56JWoh9G6-sD9MOGgmwpI18tdhA6c,16563
+if_cli/oauth.py,sha256=3ot4a61vrHNjaxBHJZaczFb4_Fz-Vzg8wmcS1P92tQA,16463
 if_cli/runtime.py,sha256=Pz2iVclqy-uu1UMQWK2P_Hx7O4zAF30UpSFqQvGN0NY,2663
 if_cli/assets/__init__.py,sha256=2vBBor8lUEQofiC6EvS5BvF_ANhfK8bfR9S0OXI8j3g,41
 if_cli/assets/insightfactoryai-logo.svg,sha256=yFxHkoHl6VNm8ppCInTZCVN_bdOog9h-NV8R4Gw1Qew,8192
@@ -17,10 +17,10 @@ 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/logout.py,sha256=TBRMoK1EafYny9fUqx_YHj9PiPPRTKBcfQ-rOtwHPl0,692
 if_cli/commands/mcp.py,sha256=iaSsqWkV1lnFjIw9y1pX1ORB1MdKiOVWgK23EDIsDB4,7342
-if_cli/commands/profiles.py,sha256=tgZP5sMqzbFHXlfvglL2plsGdU0M3joo3wvQKX45J1U,3950
-if_cli/commands/set_token.py,sha256=BVyv_QmByvllr04pE2sz8JFEscHbIgOC-7ZPg61PRoc,1886
+if_cli/commands/profiles.py,sha256=IAqifVs0gBEijYSEY_9AgiHarQsEaNCN0q0-rjSBmrA,3948
+if_cli/commands/set_token.py,sha256=u1nRAFRQwf3k_xYA3g3yW4Sfy5vbnKuwUBFK9nueWj8,1878
 if_cli/commands/token.py,sha256=CyiXkyH7vxgH91-n-XJzeHnLI6mZJwO9Js5AHvfHaeM,1120
 if_cli/router/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 if_cli/router/catalog.py,sha256=Er2ZbWTwDUVU-qBGCvyA0bIlFk3UYw_6sVUlYwBhMpI,4992
@@ -29,8 +29,8 @@ if_cli/router/log.py,sha256=wtaqsFcD3hPJRu4jCJaDMSedj-43Y07ym62YgrOm1yM,740
 if_cli/router/policy.py,sha256=CclbjuOA5mwwoQiNDa17iQeN9eXRbfy11bS9JFd8gL4,2840
 if_cli/router/server.py,sha256=yCjGAm-tnZBOTg5AfvojnLcKcZLEbQQeT9iqqX8XV5A,27397
 if_cli/router/upstream.py,sha256=Ly4fcuQRywS6db2oDYoe8F4c9hryN75FdBqSWzA09g4,18720
-insightfactory_cli-1.2.0.dev34.dist-info/METADATA,sha256=xbyLKunNzQ2g7wv-86s5ruh_-rnUyetLKVWwYINNBp8,24817
-insightfactory_cli-1.2.0.dev34.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-insightfactory_cli-1.2.0.dev34.dist-info/entry_points.txt,sha256=UlX854D7f-7dBj5F0wGdakVy6vopvP9hA1BN-gv739w,44
-insightfactory_cli-1.2.0.dev34.dist-info/licenses/LICENSE,sha256=8eZ1YAABL398qESVJc_FlK1voYQ0GAh-R_rNBQK6QH8,234
-insightfactory_cli-1.2.0.dev34.dist-info/RECORD,,
+insightfactory_cli-1.3.0.dev39.dist-info/METADATA,sha256=PLMGAAIwD1UpeUXG1BQH3Uy-BKiJlJOZAXtvR89yrIo,26005
+insightfactory_cli-1.3.0.dev39.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+insightfactory_cli-1.3.0.dev39.dist-info/entry_points.txt,sha256=UlX854D7f-7dBj5F0wGdakVy6vopvP9hA1BN-gv739w,44
+insightfactory_cli-1.3.0.dev39.dist-info/licenses/LICENSE,sha256=8eZ1YAABL398qESVJc_FlK1voYQ0GAh-R_rNBQK6QH8,234
+insightfactory_cli-1.3.0.dev39.dist-info/RECORD,,