fix(completion): extend cache TTL to 5 min + respect --profile on regions

Two fixes for shell tab-completion latency and correctness.

TTL was 30 seconds, which is too short for active terminals — users
typing in bursts often crossed the boundary and paid for a fresh
Keystone auth + list on every tab. Bump CACHE_TTL to 300 seconds;
completion data (server names, flavor IDs, region lists) changes
slowly and the old short TTL made the tab key feel sluggish.

_complete_regions in main.py ignored --profile / ORCA_PROFILE, so a
user with several profiles pointing at different clouds saw one
cloud's regions cached for the other. It now walks the context
chain (same pattern as _build_client in core/completions.py),
caches per-profile and loads the matching config.

Updated the cache-expiry test to key its "past timestamp" off the
actual CACHE_TTL constant.

Author: kallioli

orca_cli/core/cache.py

@@ -1,12 +1,18 @@
-"""Resource completion cache — 30-second TTL JSON cache for shell completion."""
+"""Resource completion cache — per-profile JSON cache for shell completion.
+
+The TTL is long on purpose (5 minutes): completion data — server names,
+flavor IDs, region lists — changes slowly, and every cache miss pays for
+a Keystone auth round-trip plus the resource GET. Short TTLs made the
+tab key feel sluggish on live terminals where users type in bursts.
+"""
 
 from __future__ import annotations
 
 import json
 import time
 from pathlib import Path
 
-CACHE_TTL = 30  # seconds
+CACHE_TTL = 300  # seconds — long enough to cover typical tab-complete sessions
 _CACHE_DIR = Path.home() / ".orca" / "cache"
 
 

orca_cli/main.py

@@ -118,20 +118,31 @@ def _complete_regions(ctx: click.Context, param: click.Parameter, incomplete: st
     """Shell completion for the global --region flag.
 
     Invoked by the shell, not exercised in pytest. Best-effort: all exceptions
-    swallow to empty — never crash the user's tab key. Results are cached for
-    30 seconds to avoid a Keystone round-trip on every Tab press.
+    swallow to empty — never crash the user's tab key. Results are cached
+    per-profile so users with several profiles don't see a mixed region
+    list.
     """
     try:
         from orca_cli.core import cache
 
-        cached = cache.load(None, "regions")
+        # Resolve the active profile so the cache file stays distinct across
+        # profiles (``~/.orca/cache/<profile>_regions.json``).
+        profile = None
+        c: click.Context | None = ctx
+        while c:
+            if "profile" in getattr(c, "params", {}) and c.params["profile"]:
+                profile = c.params["profile"]
+                break
+            c = c.parent
+
+        cached = cache.load(profile, "regions")
         if cached is not None:
             return sorted(r["id"] for r in cached if r["id"].startswith(incomplete))
 
         from orca_cli.core.client import OrcaClient
         from orca_cli.core.config import config_is_complete, load_config
 
-        config = load_config()
+        config = load_config(profile_name=profile)
         if not config_is_complete(config):
             return []
         client = OrcaClient(config)
@@ -142,7 +153,7 @@ def _complete_regions(ctx: click.Context, param: click.Parameter, incomplete: st
                 if region:
                     regions.add(region)
         client.close()
-        cache.save(None, "regions", [{"id": r} for r in sorted(regions)])
+        cache.save(profile, "regions", [{"id": r} for r in sorted(regions)])
         return sorted(r for r in regions if r.startswith(incomplete))
     except Exception:
         return []

tests/test_wait_and_dryrun.py

@@ -35,9 +35,10 @@ def test_save_and_hit(self, tmp_path, monkeypatch):
     def test_expired_returns_none(self, tmp_path, monkeypatch):
         monkeypatch.setattr("orca_cli.core.cache._CACHE_DIR", tmp_path)
         items = [{"id": "abc", "name": "my-vm"}]
-        # Write with a timestamp 60 seconds in the past
+        # Write with a timestamp well past the TTL
         p = tmp_path / "default_servers.json"
-        p.write_text(json.dumps({"ts": time.time() - 60, "items": items}))
+        p.write_text(json.dumps({"ts": time.time() - (cache.CACHE_TTL + 60),
+                                 "items": items}))
         assert cache.load(None, "servers") is None
 
     def test_invalidate_removes_file(self, tmp_path, monkeypatch):