CLI Slow Performance

It's not just one network round trip. Using https://www.mitmproxy.org/ you can see that each CLI call makes multiple network round trips, in series. For a cached `op vault list`, it's two:

HTTPS GET my.1password.com /api/v2/overview?__t=1758759373.782            200 …plication/json  3.1k 115ms
HTTPS GET my.1password.com /api/v3/account?__t=1758759374.203&attrs=tier  200 …plication/json  2.0k 125ms

For a cached `op read` it's four, all in series:

HTTPS GET  my.1password.com /api/v2/overview?__t=1758759627.806            200 …plication/json  3.1k 118ms
HTTPS GET  my.1password.com /api/v3/account?__t=1758759628.196&attrs=tier  200 …plication/json  2.0k 122ms
HTTPS GET  my.1password.com /api/v3/account?__t=1758759628.354&attrs=tier  200 …plication/json  2.0k 110ms
HTTPS GET  my.1password.com /api/v2/overview?__t=1758759628.490            200 …plication/json  3.1k 115ms

The last two requests are exact duplicates of the first two, meaning the CLI could save two round trips per call to `op item read` just by keeping the results of `/api/v3/account` and `/api/v2/overview` in memory. It could save another round trip time by requesting both `/api/v3/account` and `/api/v2/overview` in parallel rather than in series.

I also experimented with scripting mitmproxy to cache all of these requests. This effectively eliminates the network delay. The good news is that this saves ~220-500ms per CLI call (a little over 100ms per roundtrip). The bad news is that CLI calls still take a little over 400ms, which is still slow for reading at most a few kilobytes of data that is sitting locally on my machine. I'm not sure what the remaining slowdown is. Could be network roundtrips done by the 1password desktop app rather than the CLI, or could be something else.

With network delay:

$ hyperfine 'op vault list'
Benchmark 1: op vault list
  Time (mean ± σ):     649.8 ms ±   9.1 ms    [User: 76.1 ms, System: 26.4 ms]
  Range (min … max):   636.9 ms … 664.8 ms    10 runs

$ hyperfine 'op read "op://Private/gmail.com/username"'
Benchmark 1: op read "op://Private/gmail.com/username"
  Time (mean ± σ):     929.9 ms ±  17.6 ms    [User: 159.6 ms, System: 49.6 ms]
  Range (min … max):   901.2 ms … 957.1 ms    10 runs

Without network delay:

$ HTTP_PROXY=http://localhost:8080 HTTPS_PROXY=http://localhost:8080 hyperfine 'op vault list'
Benchmark 1: op vault list
  Time (mean ± σ):     414.0 ms ±   6.9 ms    [User: 60.8 ms, System: 18.2 ms]
  Range (min … max):   397.4 ms … 423.2 ms    10 runs

$ HTTP_PROXY=http://localhost:8080 HTTPS_PROXY=http://localhost:8080 hyperfine 'op read "op://Private/gmail.com/username"'
Benchmark 1: op read "op://Private/gmail.com/username"
  Time (mean ± σ):     435.5 ms ±   7.6 ms    [User: 100.5 ms, System: 31.1 ms]
  Range (min … max):   422.1 ms … 449.8 ms    10 runs

If you're interested in reproducing the mitmproxy caching, here is the script I used:

from mitmproxy import http
from urllib.parse import urlparse, parse_qs, urlencode
import json
import time

class OnePasswordCache:
    def __init__(self):
        self.cache = {}

    def get_cache_key(self, flow):
        """Generate cache key by removing __t parameter"""
        url = urlparse(flow.request.pretty_url)
        params = parse_qs(url.query)

        # Remove __t parameter for cache key
        params.pop('__t', None)

        return (
            url.scheme, url.netloc, url.path, urlencode(params),
            flow.request.headers["x-agilebits-session-id"],
        )

    def request(self, flow: http.HTTPFlow):
        # Only cache GET requests to 1password API
        if (flow.request.method == "GET" and
            "1password.com/api/" in flow.request.pretty_url):

            cache_key = self.get_cache_key(flow)

            if cache_key in self.cache:
                # Serve from cache
                cached_response = self.cache[cache_key]

                # Create response from cache
                flow.response = http.Response.make(
                    cached_response["status_code"],
                    cached_response["content"],
                    cached_response["headers"]
                )

                # Add header to indicate cache hit
                flow.response.headers["X-Cache"] = "HIT"

    def response(self, flow: http.HTTPFlow):
        # Cache successful 1password API responses
        if (flow.request.method == "GET" and
            "1password.com/api/" in flow.request.pretty_url and
            flow.response.status_code == 200):

            cache_key = self.get_cache_key(flow)

            # Only cache if we didn't serve from cache
            if "X-Cache" not in flow.response.headers:
                self.cache[cache_key] = {
                    "status_code": flow.response.status_code,
                    "content": flow.response.content,
                    "headers": dict(flow.response.headers)
                }

addons = [OnePasswordCache()]

Save as `cache_1password.py`, then run `mitmproxy -s cache_1password.py -p 8080`.