plugsync-cli 0.4.0__tar.gz → 0.5.0__tar.gz

{plugsync_cli-0.4.0 → plugsync_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugsync-cli
-Version: 0.4.0
+Version: 0.5.0
 Summary: Command-line client for plugsync HubSpot connectors -- manage connectors and plugins like code, no repo checkout required
 Author-email: Exelab <hello@plugsync.com>
 License: Proprietary
@@ -75,6 +75,8 @@ override the config file, handy for CI.
 | `plugsync preview <name>` | Preview a publish's effects and its preflight findings |
 | `plugsync log <name>` | Show a connector's published version history |
 | `plugsync rollback <name>` | Restore a published version into the draft |
+| `plugsync connector breakers <name>` | List the connector's flows whose circuit breaker is open |
+| `plugsync connector flow retry <name> <flow>` | Retry one blocked flow now, instead of waiting for its automatic attempt |
 | `plugsync plugin init/push/list/status/logs/metrics/invoke/promote/publish/rollback` | Author and manage plugins (Enterprise tier) |
 
 Run `plugsync --help` or `plugsync <command> --help` for the full option list.

{plugsync_cli-0.4.0 → plugsync_cli-0.5.0}/README.md

@@ -44,6 +44,8 @@ override the config file, handy for CI.
 | `plugsync preview <name>` | Preview a publish's effects and its preflight findings |
 | `plugsync log <name>` | Show a connector's published version history |
 | `plugsync rollback <name>` | Restore a published version into the draft |
+| `plugsync connector breakers <name>` | List the connector's flows whose circuit breaker is open |
+| `plugsync connector flow retry <name> <flow>` | Retry one blocked flow now, instead of waiting for its automatic attempt |
 | `plugsync plugin init/push/list/status/logs/metrics/invoke/promote/publish/rollback` | Author and manage plugins (Enterprise tier) |
 
 Run `plugsync --help` or `plugsync <command> --help` for the full option list.

{plugsync_cli-0.4.0 → plugsync_cli-0.5.0}/plugsync_cli/__init__.py

@@ -1,2 +1,2 @@
 """PluSync CLI — git-like connector management."""
-__version__ = "0.4.0"
+__version__ = "0.5.0"

{plugsync_cli-0.4.0 → plugsync_cli-0.5.0}/plugsync_cli/client.py

@@ -1,5 +1,6 @@
 """HTTP client wrapper for PluSync REST API."""
 import json
+from urllib.parse import quote
 
 import httpx
 
@@ -120,6 +121,30 @@ class PlugSyncClient:
             r.raise_for_status()
             return r.json()
 
+    def retry_flow(self, connector_id: str, flow_name: str) -> dict:
+        """Retry one flow whose circuit breaker is open, returning the
+        refreshed connector.
+
+        The API moves the breaker to `half_open`, which makes the next message
+        through that flow the recovery probe: it is not a close, and a failed
+        probe re-opens the breaker with a longer cooldown. Idempotent when the
+        breaker is already half-open; 404 when the flow has no open breaker at
+        all, which the command translates into "nothing to retry".
+
+        The flow name is a config value, not a URL-safe token, so it is quoted
+        with no safe characters: a flow called `orders/eu` has to reach the API
+        as one path segment rather than two.
+        """
+        with self._client() as c:
+            r = c.post(
+                self._url(
+                    f"/connectors/{connector_id}/flows/"
+                    f"{quote(flow_name, safe='')}/retry"
+                )
+            )
+            r.raise_for_status()
+            return r.json()
+
     def get_draft(self, connector_id: str) -> dict:
         """The connector's editable config (backend DraftResponse).
 

plugsync_cli-0.5.0/plugsync_cli/commands/connector.py

@@ -0,0 +1,253 @@
+"""plugsync connector -- read a connector's flow circuit breakers, retry one.
+
+Self-service only, with the same org-scoped auth as every other command: the
+owner of a connector lists the flows whose circuit breaker is open and retries
+one of them, from a script or from CI, without opening the dashboard. The
+platform-side force-close is a different operation with a different
+authentication contract (it refuses an org API key) and deliberately has no
+command here.
+"""
+import uuid
+from datetime import datetime, timezone
+
+import click
+import httpx
+from rich.console import Console
+from rich.table import Table
+
+from plugsync_cli.client import PlugSyncClient
+from plugsync_cli.context import build_client, fail
+
+console = Console()
+
+_CONNECTOR_NOT_FOUND = (
+    "Connector '{label}' not found, or it does not belong to this organization."
+)
+
+
+def _looks_like_a_connector_id(reference: str) -> bool:
+    try:
+        uuid.UUID(reference)
+    except ValueError:
+        return False
+    return True
+
+
+def _resolve_connector(client: PlugSyncClient, reference: str) -> tuple[str, str]:
+    """A connector reference (name or id) as `(connector_id, label)`.
+
+    A UUID is taken as the id and used as-is: resolving it through the
+    connector listing would cost a round trip to learn a name the endpoints
+    already return in their own response.
+    """
+    if _looks_like_a_connector_id(reference):
+        return reference, reference
+    connector = client.find_connector(reference)
+    if not connector:
+        fail(f"Connector '{reference}' not found")
+    return connector["id"], connector.get("name") or reference
+
+
+def _detail(exc: httpx.HTTPStatusError) -> str:
+    """The API's `detail` string, or "" when the body carries none."""
+    try:
+        payload = exc.response.json()
+    except ValueError:
+        return ""
+    detail = payload.get("detail") if isinstance(payload, dict) else None
+    return detail if isinstance(detail, str) else ""
+
+
+def _open_breakers(connector: dict) -> list[dict]:
+    """The connector's non-closed flow breakers, one shape for two payloads.
+
+    `health.flows` is the richer form and the one to read. An API that predates
+    it answers only the legacy list, which carries the same flows under other
+    key names: normalizing it here keeps such a backend from reading as a
+    connector with nothing blocked.
+    """
+    flows = (connector.get("health") or {}).get("flows")
+    if flows:
+        return flows
+    return [
+        {
+            "name": flow.get("flow_name"),
+            "state": flow.get("state"),
+            "detail": flow.get("reason"),
+            "opened_at": flow.get("tripped_at"),
+        }
+        for flow in connector.get("tripped_flows") or []
+    ]
+
+
+def _breaker_for(connector: dict, flow_name: str) -> dict | None:
+    for breaker in _open_breakers(connector):
+        if breaker.get("name") == flow_name:
+            return breaker
+    return None
+
+
+def _reason(breaker: dict) -> str:
+    """The human-readable diagnostic, falling back to the machine code."""
+    return str(breaker.get("detail") or breaker.get("reason") or "")
+
+
+def _relative(value, *, now: datetime | None = None) -> str:
+    """An ISO timestamp as a short relative time, past or future.
+
+    Both directions matter in one table: a breaker opened in the past, and a
+    cooldown that expires in the future. An unparseable value is printed as it
+    arrived rather than dropped.
+    """
+    if not value:
+        return ""
+    try:
+        moment = datetime.fromisoformat(str(value).replace("Z", "+00:00"))
+    except ValueError:
+        return str(value)
+    if moment.tzinfo is None:
+        moment = moment.replace(tzinfo=timezone.utc)
+
+    delta = (moment - (now or datetime.now(timezone.utc))).total_seconds()
+    seconds = int(abs(delta))
+    if seconds < 60:
+        return "now"
+    if seconds < 3600:
+        magnitude = f"{seconds // 60}m"
+    elif seconds < 86400:
+        magnitude = f"{seconds // 3600}h"
+    else:
+        magnitude = f"{seconds // 86400}d"
+    return f"in {magnitude}" if delta > 0 else f"{magnitude} ago"
+
+
+@click.group()
+def connector():
+    """Inspect a connector's operational state."""
+    pass
+
+
+@connector.group()
+def flow():
+    """Act on one event flow of a connector."""
+    pass
+
+
+@flow.command("retry")
+@click.argument("connector_reference", metavar="CONNECTOR")
+@click.argument("flow_name", metavar="FLOW")
+def flow_retry(connector_reference: str, flow_name: str):
+    """Retry a flow whose circuit breaker is open.
+
+    CONNECTOR is a connector name or id, FLOW the event flow name. The breaker
+    moves to half-open: the next message through the flow is the recovery
+    probe. It is not a force-close, and a failed probe re-opens the breaker
+    with a longer cooldown.
+
+    Examples:
+        plugsync connector flow retry my-connector shop-orders
+    """
+    client = build_client()
+    connector_id, label = _resolve_connector(client, connector_reference)
+
+    try:
+        updated = client.retry_flow(connector_id, flow_name)
+    except httpx.HTTPStatusError as exc:
+        if exc.response.status_code != 404:
+            raise
+        if "connector not found" in _detail(exc).lower():
+            fail(_CONNECTOR_NOT_FOUND.format(label=label))
+        fail(
+            f"Flow '{flow_name}' has no open circuit breaker on '{label}': "
+            f"nothing to retry. Run 'plugsync connector breakers {label}' to "
+            "list the flows that are blocked."
+        )
+
+    name = updated.get("name") or label
+    breaker = _breaker_for(updated, flow_name)
+    if breaker is None:
+        console.print(
+            f"Retry accepted for flow '{flow_name}' on connector '{name}', but "
+            "the flow no longer appears among its open circuit breakers: there "
+            "is no breaker state left to report.",
+            soft_wrap=True,
+        )
+        return
+
+    state = breaker.get("state") or "unknown"
+    console.print(
+        f"[green]Flow '{flow_name}' on connector '{name}': breaker is now "
+        f"{state}.[/green]",
+        soft_wrap=True,
+    )
+    if state == "half_open":
+        console.print(
+            "The next message through this flow is the recovery probe: if it "
+            "succeeds the breaker closes, if it fails the breaker re-opens "
+            "with a longer cooldown.",
+            soft_wrap=True,
+        )
+
+
+@connector.command("breakers")
+@click.argument("connector_reference", metavar="CONNECTOR")
+def connector_breakers(connector_reference: str):
+    """List the flows of a connector whose circuit breaker is open.
+
+    CONNECTOR is a connector name or id. Read-only, and always exits 0 when it
+    could read the connector: a blocked flow is not a command failure.
+
+    Examples:
+        plugsync connector breakers my-connector
+    """
+    client = build_client()
+    connector_id, label = _resolve_connector(client, connector_reference)
+
+    try:
+        data = client.get_connector(connector_id)
+    except httpx.HTTPStatusError as exc:
+        if exc.response.status_code != 404:
+            raise
+        fail(_CONNECTOR_NOT_FOUND.format(label=label))
+
+    name = data.get("name") or label
+    breakers = _open_breakers(data)
+    if not breakers:
+        console.print(f"[green]No open circuit breaker on '{name}'.[/green]")
+        return
+
+    table = Table(show_header=True, header_style="bold", box=None, padding=(0, 2))
+    # `overflow="fold"` on the flow name: rich shrinks the widest column when
+    # the table outgrows the terminal, and the default is an ellipsis. The
+    # name is exactly what the operator has to retype into `flow retry`, so it
+    # wraps rather than being cut. `Reason` comes last for the same reason --
+    # it is the column the wrapping should land on.
+    table.add_column("Flow", overflow="fold")
+    table.add_column("State")
+    table.add_column("Opened")
+    table.add_column("Retry after")
+    table.add_column("Opens", justify="right")
+    table.add_column("Reason", overflow="fold")
+
+    for breaker in breakers:
+        opens = breaker.get("opens")
+        table.add_row(
+            str(breaker.get("name") or ""),
+            str(breaker.get("state") or ""),
+            _relative(breaker.get("opened_at")),
+            _relative(breaker.get("retry_after_at")),
+            "" if opens is None else str(opens),
+            _reason(breaker),
+        )
+
+    console.print(f"\n[bold]Open circuit breakers: {name}[/bold]\n")
+    console.print(table)
+    console.print(
+        f"\nRetry one now with: plugsync connector flow retry {name} <flow>",
+        soft_wrap=True,
+    )
+    console.print(
+        "A flow whose retry window has already passed is probed automatically "
+        "by the next message it receives.\n",
+        soft_wrap=True,
+    )

{plugsync_cli-0.4.0 → plugsync_cli-0.5.0}/plugsync_cli/main.py

@@ -115,6 +115,7 @@ from plugsync_cli.commands.log import log_cmd
 from plugsync_cli.commands.rollback import rollback
 from plugsync_cli.commands.plugin import plugin
 from plugsync_cli.commands.auth import auth
+from plugsync_cli.commands.connector import connector
 
 cli.add_command(pull)
 cli.add_command(push)
@@ -125,3 +126,4 @@ cli.add_command(log_cmd)
 cli.add_command(rollback)
 cli.add_command(plugin)
 cli.add_command(auth)
+cli.add_command(connector)

{plugsync_cli-0.4.0 → plugsync_cli-0.5.0}/plugsync_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugsync-cli
-Version: 0.4.0
+Version: 0.5.0
 Summary: Command-line client for plugsync HubSpot connectors -- manage connectors and plugins like code, no repo checkout required
 Author-email: Exelab <hello@plugsync.com>
 License: Proprietary
@@ -75,6 +75,8 @@ override the config file, handy for CI.
 | `plugsync preview <name>` | Preview a publish's effects and its preflight findings |
 | `plugsync log <name>` | Show a connector's published version history |
 | `plugsync rollback <name>` | Restore a published version into the draft |
+| `plugsync connector breakers <name>` | List the connector's flows whose circuit breaker is open |
+| `plugsync connector flow retry <name> <flow>` | Retry one blocked flow now, instead of waiting for its automatic attempt |
 | `plugsync plugin init/push/list/status/logs/metrics/invoke/promote/publish/rollback` | Author and manage plugins (Enterprise tier) |
 
 Run `plugsync --help` or `plugsync <command> --help` for the full option list.

{plugsync_cli-0.4.0 → plugsync_cli-0.5.0}/plugsync_cli.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ plugsync_cli.egg-info/requires.txt
 plugsync_cli.egg-info/top_level.txt
 plugsync_cli/commands/__init__.py
 plugsync_cli/commands/auth.py
+plugsync_cli/commands/connector.py
 plugsync_cli/commands/diff.py
 plugsync_cli/commands/log.py
 plugsync_cli/commands/plugin.py
@@ -32,6 +33,7 @@ tests/test_client.py
 tests/test_commands.py
 tests/test_compat.py
 tests/test_config.py
+tests/test_connector_commands.py
 tests/test_e2e_draft_api.py
 tests/test_hand_edited_yaml.py
 tests/test_plugin_commands.py

{plugsync_cli-0.4.0 → plugsync_cli-0.5.0}/pyproject.toml

@@ -11,7 +11,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "plugsync-cli"
-version = "0.4.0"
+version = "0.5.0"
 description = "Command-line client for plugsync HubSpot connectors -- manage connectors and plugins like code, no repo checkout required"
 readme = "README.md"
 license = { text = "Proprietary" }

{plugsync_cli-0.4.0 → plugsync_cli-0.5.0}/tests/test_api_contract.py

@@ -64,6 +64,10 @@ DELEGATING_CALLS: dict[str, tuple] = {
 CLIENT_CALLS: dict[str, tuple] = {
     "list_connectors": (),
     "get_connector": (CONNECTOR_ID,),
+    # A flow name with no character the path has to escape: the guard resolves
+    # a concrete path against the OpenAPI templates segment by segment, so a
+    # percent-encoded sentinel would only make the match harder to read.
+    "retry_flow": (CONNECTOR_ID, "shop-orders"),
     "get_draft": (CONNECTOR_ID,),
     "put_draft": (CONNECTOR_ID, {"version": "3.1", "entities": [], "flows": []}),
     "config_surface": (),

plugsync_cli-0.5.0/tests/test_connector_commands.py

@@ -0,0 +1,285 @@
+"""Tests for `plugsync connector` -- flow circuit breakers over the org key.
+
+The client is mocked here, as in test_commands.py: these cover argument
+handling, the rendering of a `ConnectorResponse` and the 404 branches. That
+the mocked calls hit endpoints which actually exist is
+`test_api_contract.py`'s job.
+"""
+from unittest.mock import MagicMock, patch
+
+import httpx
+from click.testing import CliRunner
+
+from plugsync_cli.main import cli
+
+CONNECTOR_ID = "11111111-1111-1111-1111-111111111111"
+ORG_ID = "22222222-2222-2222-2222-222222222222"
+
+
+def _flat(output: str) -> str:
+    """Output with wrapping collapsed: rich hard-wraps at the console width,
+    so a message is asserted on its words, not on where the line broke."""
+    return " ".join(output.split())
+
+
+def _breaker(name: str = "shop-orders", state: str = "open", **overrides) -> dict:
+    """One `health.flows` entry (backend `FlowBreakerState`)."""
+    row = {
+        "name": name,
+        "state": state,
+        "reason": "fatal_streak",
+        "detail": "upsert refused",
+        "opened_at": "2026-09-10T08:00:00Z",
+        "retry_after_at": "2026-09-10T08:05:00Z",
+        "cooldown_seconds": 300,
+        "opens": 2,
+    }
+    row.update(overrides)
+    return row
+
+
+def _connector(
+    name: str = "shop",
+    breakers: list[dict] | None = None,
+    tripped_flows: list[dict] | None = None,
+    health_state: str = "degraded",
+) -> dict:
+    """What the connector endpoints answer (backend `ConnectorResponse`)."""
+    return {
+        "id": CONNECTOR_ID,
+        "name": name,
+        "status": "active",
+        "org_id": ORG_ID,
+        "direction": "inbound",
+        "settings": {},
+        "mode": "live",
+        "tripped_flows": tripped_flows or [],
+        "health": {"state": health_state, "flows": breakers or []},
+        "created_at": "2026-09-01T10:00:00Z",
+        "updated_at": "2026-09-10T08:00:00Z",
+    }
+
+
+def _client(**attrs) -> MagicMock:
+    client = MagicMock()
+    client.find_connector.return_value = {"id": CONNECTOR_ID, "name": "shop"}
+    client.get_connector.return_value = _connector()
+    client.retry_flow.return_value = _connector()
+    for key, value in attrs.items():
+        setattr(client, key, value)
+    return client
+
+
+def _http_error(status: int, payload, method: str = "POST", path: str = "/api/x"):
+    """The httpx exception a non-2xx raises inside the client."""
+    request = httpx.Request(method, f"https://api.test{path}")
+    response = httpx.Response(status, json=payload, request=request)
+    return httpx.HTTPStatusError("boom", request=request, response=response)
+
+
+def _run(client: MagicMock, args: list[str]):
+    runner = CliRunner()
+    with patch("plugsync_cli.context.PlugSyncClient", return_value=client):
+        return runner.invoke(cli, args)
+
+
+class TestFlowRetry:
+    def test_retry_reports_the_half_open_probe(self):
+        client = _client(
+            retry_flow=MagicMock(
+                return_value=_connector(breakers=[_breaker(state="half_open")])
+            )
+        )
+
+        result = _run(client, ["connector", "flow", "retry", "shop", "shop-orders"])
+
+        assert result.exit_code == 0, result.output
+        client.retry_flow.assert_called_once_with(CONNECTOR_ID, "shop-orders")
+        output = _flat(result.output)
+        assert "shop-orders" in output
+        assert "half_open" in output
+        assert "recovery probe" in output
+
+    def test_retry_accepts_a_connector_id_without_a_name_lookup(self):
+        """A UUID argument is the connector id: no listing round trip for it."""
+        client = _client(
+            retry_flow=MagicMock(
+                return_value=_connector(breakers=[_breaker(state="half_open")])
+            )
+        )
+
+        result = _run(
+            client, ["connector", "flow", "retry", CONNECTOR_ID, "shop-orders"]
+        )
+
+        assert result.exit_code == 0, result.output
+        client.find_connector.assert_not_called()
+        client.retry_flow.assert_called_once_with(CONNECTOR_ID, "shop-orders")
+
+    def test_a_flow_with_no_open_breaker_is_reported_not_raised(self):
+        """The API's 404 for "nothing to retry", said in the CLI's own words."""
+        client = _client(
+            retry_flow=MagicMock(
+                side_effect=_http_error(
+                    404,
+                    {"detail": "Flow 'shop-orders' has no open circuit breaker to retry"},
+                )
+            )
+        )
+
+        result = _run(client, ["connector", "flow", "retry", "shop", "shop-orders"])
+
+        assert result.exit_code == 1
+        assert result.exception is None or isinstance(result.exception, SystemExit)
+        output = _flat(result.output)
+        assert "no open circuit breaker" in output
+        assert "nothing to retry" in output
+        assert "Traceback" not in result.output
+
+    def test_a_connector_of_another_org_is_reported(self):
+        client = _client(
+            retry_flow=MagicMock(
+                side_effect=_http_error(404, {"detail": "Connector not found"})
+            )
+        )
+
+        result = _run(
+            client, ["connector", "flow", "retry", CONNECTOR_ID, "shop-orders"]
+        )
+
+        assert result.exit_code == 1
+        output = _flat(result.output)
+        assert "not found" in output
+        assert "nothing to retry" not in output
+
+    def test_an_unknown_connector_name_is_reported(self):
+        client = _client(find_connector=MagicMock(return_value=None))
+
+        result = _run(client, ["connector", "flow", "retry", "nope", "shop-orders"])
+
+        assert result.exit_code == 1
+        assert "Connector 'nope' not found" in _flat(result.output)
+        client.retry_flow.assert_not_called()
+
+    def test_a_response_without_the_flow_does_not_invent_a_state(self):
+        """The retry went through, but the answer carries no breaker for the
+        flow: report that rather than claiming a state nobody sent."""
+        client = _client(retry_flow=MagicMock(return_value=_connector(breakers=[])))
+
+        result = _run(client, ["connector", "flow", "retry", "shop", "shop-orders"])
+
+        assert result.exit_code == 0, result.output
+        output = _flat(result.output)
+        assert "half_open" not in output
+        assert "no longer appears" in output
+
+    def test_a_non_404_reaches_the_generic_handler(self):
+        """Only the 404 is special-cased; the rest keeps the group's rendering
+        (message from the response body, no traceback)."""
+        client = _client(
+            retry_flow=MagicMock(
+                side_effect=_http_error(
+                    503, {"detail": "Service Unavailable"}, path="/api/connectors/x"
+                )
+            )
+        )
+
+        result = _run(client, ["connector", "flow", "retry", "shop", "shop-orders"])
+
+        assert result.exit_code == 1
+        assert result.exception is None or isinstance(result.exception, SystemExit)
+        output = _flat(result.output)
+        assert "503" in output
+        assert "Service Unavailable" in output
+
+
+class TestBreakers:
+    def test_the_open_breakers_are_listed(self):
+        client = _client(
+            get_connector=MagicMock(
+                return_value=_connector(
+                    breakers=[
+                        _breaker(name="shop-orders", state="open"),
+                        _breaker(name="crm-sync", state="half_open", opens=5),
+                    ]
+                )
+            )
+        )
+
+        result = _run(client, ["connector", "breakers", "shop"])
+
+        assert result.exit_code == 0, result.output
+        client.get_connector.assert_called_once_with(CONNECTOR_ID)
+        output = _flat(result.output)
+        assert "shop-orders" in output
+        assert "crm-sync" in output
+        assert "open" in output
+        assert "half_open" in output
+        assert "upsert refused" in output
+        # The footer points at the command that acts on what was just listed.
+        assert "plugsync connector flow retry" in output
+
+    def test_no_open_breaker_is_said_plainly(self):
+        client = _client(get_connector=MagicMock(return_value=_connector()))
+
+        result = _run(client, ["connector", "breakers", "shop"])
+
+        assert result.exit_code == 0, result.output
+        assert "No open circuit breaker on 'shop'" in _flat(result.output)
+
+    def test_an_api_without_the_health_rollup_still_lists_the_flows(self):
+        """An older API carries only the legacy list; render that instead of
+        reporting a healthy connector."""
+        client = _client(
+            get_connector=MagicMock(
+                return_value={
+                    "id": CONNECTOR_ID,
+                    "name": "shop",
+                    "status": "active",
+                    "org_id": ORG_ID,
+                    "settings": {},
+                    "mode": "live",
+                    "tripped_flows": [
+                        {
+                            "flow_name": "shop-orders",
+                            "reason": "upsert refused",
+                            "state": "open",
+                            "tripped_at": "2026-09-10T08:00:00Z",
+                        }
+                    ],
+                    "created_at": "2026-09-01T10:00:00Z",
+                    "updated_at": "2026-09-10T08:00:00Z",
+                }
+            )
+        )
+
+        result = _run(client, ["connector", "breakers", "shop"])
+
+        assert result.exit_code == 0, result.output
+        output = _flat(result.output)
+        assert "shop-orders" in output
+        assert "upsert refused" in output
+
+    def test_an_unknown_connector_name_is_reported(self):
+        client = _client(find_connector=MagicMock(return_value=None))
+
+        result = _run(client, ["connector", "breakers", "nope"])
+
+        assert result.exit_code == 1
+        assert "Connector 'nope' not found" in _flat(result.output)
+        client.get_connector.assert_not_called()
+
+    def test_a_connector_of_another_org_is_reported(self):
+        client = _client(
+            get_connector=MagicMock(
+                side_effect=_http_error(
+                    404, {"detail": "Connector not found"}, method="GET"
+                )
+            )
+        )
+
+        result = _run(client, ["connector", "breakers", CONNECTOR_ID])
+
+        assert result.exit_code == 1
+        assert result.exception is None or isinstance(result.exception, SystemExit)
+        assert "not found" in _flat(result.output)