deepsieve-cli 0.2.0__tar.gz → 0.3.0__tar.gz

{deepsieve_cli-0.2.0 → deepsieve_cli-0.3.0}/.gitignore

@@ -132,3 +132,10 @@ page-*.yml
 
 # Antigravity (Gemini) agent local config — per-machine, like .claude/settings.local.json
 .agents/
+
+# --- Review-seat scratch (`.review-<ticket>/`) ---
+# Reviewer briefs and seat reports written into a worktree for a review round.
+# `.review-1539/` reached `development` in #1561 through a `git add -A` — the
+# same mechanism as the node_modules note above, a second time. Reports belong
+# in the session scratchpad; a copy in the tree is only ever a transient.
+.review-*/

{deepsieve_cli-0.2.0 → deepsieve_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: deepsieve-cli
-Version: 0.2.0
+Version: 0.3.0
 Summary: DeepSieve CLI — run cited deep research from your terminal
 Requires-Python: >=3.11
 Requires-Dist: httpx>=0.27
@@ -26,6 +26,7 @@ revoked there at any time.
 deepsieve whoami                              # identity, workspace, scopes
 deepsieve runs create --query "..." --dry-run # free simulated run (~15s)
 deepsieve runs create --query "..." --wait    # real run: spends credits
+deepsieve runs create --seeds "..." --allowed-source "*.gov"  # only cite these
 deepsieve runs list
 deepsieve runs get <id>                       # exit 4 while still running
 deepsieve runs cancel <id>

{deepsieve_cli-0.2.0 → deepsieve_cli-0.3.0}/README.md

@@ -18,6 +18,7 @@ revoked there at any time.
 deepsieve whoami                              # identity, workspace, scopes
 deepsieve runs create --query "..." --dry-run # free simulated run (~15s)
 deepsieve runs create --query "..." --wait    # real run: spends credits
+deepsieve runs create --seeds "..." --allowed-source "*.gov"  # only cite these
 deepsieve runs list
 deepsieve runs get <id>                       # exit 4 while still running
 deepsieve runs cancel <id>

{deepsieve_cli-0.2.0 → deepsieve_cli-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepsieve-cli"
-version = "0.2.0"
+version = "0.3.0"
 description = "DeepSieve CLI — run cited deep research from your terminal"
 requires-python = ">=3.11"
 readme = "README.md"

{deepsieve_cli-0.2.0 → deepsieve_cli-0.3.0}/src/deepsieve_cli/main.py

@@ -250,6 +250,11 @@ def cmd_runs_create(args) -> int:
         body["query"] = args.query
     if args.seeds:
         body["seeds"] = [s.strip() for s in args.seeds.split(",") if s.strip()]
+    allowed = [s.strip() for s in (getattr(args, "allowed_source", None) or []) if s.strip()]
+    if allowed:
+        # #1802 — repeatable; the server resolves and refuses, the CLI only carries.
+        # Only blanks given → no list at all, never an empty one (the server 400s on []).
+        body["allowed_sources"] = allowed
 
     # A real run spends money. Confirm interactively unless told not to — and
     # never silently in a pipe, where nobody is watching.
@@ -451,21 +456,120 @@ def _remote_server_name(prof) -> str:
     return "deepsieve"
 
 
+def _remote_oauth_enabled(prof) -> bool | None:
+    """Whether this deployment serves remote MCP browser-OAuth.
+
+    Probes the RFC 9728 discovery document, which ``api/routes/mcp.py`` serves
+    with a 200 only when the deployment's ``oauth_enabled()`` (``authkit_domain``
+    + ``mcp_base_url``) is true, and a 404 (``MCP OAuth not configured``)
+    otherwise. Unauthenticated, so it works before anyone has signed in — the
+    situation this command exists for.
+
+    Three states, not two — the distinction is load-bearing (#1798):
+
+    - ``True``  — a 200: OAuth is live, emit the HTTP/browser registration.
+    - ``False`` — the documented **404** (``MCP OAuth not configured``): the one
+      definitive "OAuth is off" signal → fall back to the local stdio server.
+    - ``None``  — could not determine: a network error, OR any other non-2xx the
+      app itself never emits (a 5xx/504 from the ALB, a 429, a WAF 403 — a 503
+      deploy blip is the live example). We must NOT read those as "OAuth off":
+      that would relocate the found-nothing/could-not-look collapse this ticket
+      fixes to the 5xx boundary and render a transient error as the categorical
+      "no browser login". The caller keeps the HTTP default on ``None`` (a
+      normally-reachable origin usually has whatever it has) but says the answer
+      is unverified; only a definitive ``False`` flips to stdio.
+    """
+    try:
+        Client(prof.origin).request("GET", "/.well-known/oauth-protected-resource")
+        return True
+    except ApiError as exc:
+        # Only the 404 is definitive. `http_404` is what `client.request` derives
+        # for the route's `{"detail": ...}` body (no `error` envelope → the
+        # status-code default). Everything else is "could not determine".
+        return False if exc.code == "http_404" else None
+
+
 def cmd_setup_mcp(args) -> int:
-    """Print (or install) the MCP registration for this profile's origin."""
+    """Print (or install) the MCP registration for this profile's origin.
+
+    Emits the transport the deployment actually supports: remote HTTP + browser
+    OAuth when it is configured, else the local stdio server keyed off
+    ``DEEPSIEVE_API_KEY``. Both the human and ``--json`` output derive that
+    choice from the SAME live probe (`_remote_oauth_enabled`), so the two can
+    never advertise different transports — #1798, where the served ``setup.md``
+    and this command both hardcoded HTTP and dead-ended every agent on a
+    deployment without OAuth.
+    """
     _, prof = _client(args)
-    url = f"{prof.origin}/mcp"
     # Ask the deployment what it calls itself rather than assuming "deepsieve":
     # hardcoding it here would print a staging registration that overwrites the
     # production entry — the exact collision the env-aware naming fixed.
     name = args.name or _remote_server_name(prof)
+
+    oauth = _remote_oauth_enabled(prof)
+    # Three probe outcomes get three distinct renderings — "could not look" must
+    # never be byte-identical to "confirmed OAuth" (#1798). The `oauth_discovery`
+    # marker rides every --json payload; the human output states an unverified
+    # default in words. `unconfirmed` covers both an unreachable origin and any
+    # non-404 status (e.g. a 5xx) — neither is a definitive "OAuth off". Only a
+    # definitive `False` (the 404) flips us off the HTTP path.
+    discovery = {True: "confirmed", False: "absent", None: "unconfirmed"}[oauth]
+    # The stdio registration line — the primary path when OAuth is absent, and
+    # the fallback hint when discovery was unreachable. One definition, so the
+    # two spots cannot drift.
+    stdio_add = f"claude mcp add {name} --env DEEPSIEVE_API_URL={prof.origin} -- uvx deepsieve-mcp"
+
+    if oauth is False:
+        # No remote OAuth on this deployment → local stdio server. The key is
+        # never inlined: the server inherits DEEPSIEVE_API_KEY from the
+        # environment, the rule setup.md enforces (a key in a config file gets
+        # committed/logged).
+        cfg = {
+            "command": "uvx",
+            "args": ["deepsieve-mcp"],
+            "env": {"DEEPSIEVE_API_URL": prof.origin},
+        }
+        if args.json:
+            out({"mcpServers": {name: cfg}, "oauth_discovery": discovery}, True)
+            return EXIT_OK
+        print(f"This deployment has no browser login — register the local {name} MCP server.\n")
+        print(
+            f"Set DEEPSIEVE_API_KEY in your environment (an Agent key from "
+            f"{prof.origin}/settings/api-keys), then:\n"
+        )
+        print(f"  {stdio_add}\n")
+        print(
+            "Or add to your agent's MCP config (the server inherits DEEPSIEVE_API_KEY "
+            "from the environment — do not inline the key):\n"
+        )
+        print(json.dumps({"mcpServers": {name: cfg}}, indent=2))
+        print(f"\nFull setup, including skills and rules: {prof.origin}/setup.md")
+        return EXIT_OK
+
+    # OAuth confirmed (200) OR unreachable (None): both register the HTTP
+    # endpoint, but the unreachable case says so in words — an unverified default
+    # dressed as a verified one walks the agent into the exact dead Authenticate
+    # button this ticket exists to remove.
+    url = f"{prof.origin}/mcp"
     if args.json:
-        out({"mcpServers": {name: {"url": url}}}, True)
+        out({"mcpServers": {name: {"url": url}}, "oauth_discovery": discovery}, True)
         return EXIT_OK
+    if oauth is None:
+        print(
+            f"Could not confirm {prof.origin} offers browser login (no response, or an "
+            "unexpected status); defaulting to the HTTP endpoint.\n"
+        )
     print(f"Register the {name} MCP server (browser login, no key needed):\n")
     print(f"  claude mcp add --transport http {name} {url}\n")
     print("Or add to your agent's MCP config:\n")
     print(json.dumps({"mcpServers": {name: {"url": url}}}, indent=2))
+    if oauth is None:
+        print(
+            "\nIf Authenticate does nothing, this deployment has no remote OAuth — "
+            "re-run when it is reachable, or use the local stdio server:\n"
+            f"  {stdio_add}\n"
+            "(the stdio server needs DEEPSIEVE_API_KEY in the environment)."
+        )
     print(f"\nFull setup, including skills and rules: {prof.origin}/setup.md")
     return EXIT_OK
 
@@ -531,6 +635,10 @@ def build_parser() -> argparse.ArgumentParser:
     rc = runs.add_parser("create", help="start a run", parents=[common])
     rc.add_argument("--query")
     rc.add_argument("--seeds", help="comma-separated names or URLs")
+    rc.add_argument("--allowed-source", action="append", metavar="PATTERN",
+                    help="restrict evidence to this source (repeatable): a host, *.gov, "
+                         "https://host/path/*, or blueprint:primary; a cell cited only "
+                         "elsewhere is not written")
     rc.add_argument("--depth", default="standard", choices=["standard", "max"])
     rc.add_argument("--dry-run", action="store_true", help="free simulated run (~15s)")
     rc.add_argument("--no-monitor", dest="monitored", action="store_false",

{deepsieve_cli-0.2.0 → deepsieve_cli-0.3.0}/tests/test_cli.py

@@ -386,7 +386,14 @@ def test_setup_mcp_reads_the_name_from_the_deployment(monkeypatch, capsys):
     cfg.save_profile(cfg.Profile(name="staging", origin="https://staging.test", api_key="k"))
 
     def handler(request: httpx.Request) -> httpx.Response:
-        assert request.url.path == "/setup.md", "must not need an authenticated endpoint"
+        # Both endpoints the command touches (the name lookup and the OAuth
+        # discovery probe) are unauthenticated; neither may be /api/system/status.
+        assert request.url.path in (
+            "/setup.md",
+            "/.well-known/oauth-protected-resource",
+        ), "must not need an authenticated endpoint"
+        if request.url.path == "/.well-known/oauth-protected-resource":
+            return httpx.Response(200, json={"resource": "https://staging.test/mcp"})
         return httpx.Response(
             200,
             text=(
@@ -420,6 +427,140 @@ def test_setup_mcp_falls_back_to_the_brand_not_the_hostname(monkeypatch, capsys)
     assert " staging " not in printed, f"leaked a hostname label as the name: {printed}"
 
 
+# ── #1798: the transport must match what the deployment actually serves ───────
+#
+# setup.md and `deepsieve setup mcp` used to hardcode the remote HTTP + browser
+# OAuth path. On a deployment where OAuth is not configured, the discovery doc
+# 404s and no /mcp transport is mounted, so an agent following the snippet
+# dead-ends at an inoperative Authenticate button. Both tests assert the PROBE
+# FIRED and the BRANCH TAKEN — a snippet that renders correctly while the probe
+# never ran is the exact failure we are fixing.
+
+
+def _setup_mcp_handler(seen, *, oauth_status):
+    """A handler that records paths and answers the OAuth discovery probe with
+    `oauth_status`. /setup.md carries the canonical name line."""
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen.append(request.url.path)
+        if request.url.path == "/.well-known/oauth-protected-resource":
+            if oauth_status == 200:
+                return httpx.Response(200, json={"resource": "https://x.test/mcp"})
+            return httpx.Response(oauth_status, json={"detail": "MCP OAuth not configured"})
+        if request.url.path == "/setup.md":
+            return httpx.Response(
+                200,
+                text="```bash\nclaude mcp add --transport http deepsieve https://x.test/mcp\n```\n",
+            )
+        return httpx.Response(404, json={"detail": "Not Found"})
+
+    return handler
+
+
+def test_setup_mcp_emits_http_when_oauth_is_configured(monkeypatch, capsys):
+    """A 200 on the discovery doc → the browser-OAuth HTTP registration."""
+    cfg.save_profile(cfg.Profile(name="default", origin="https://x.test", api_key="ds_live_SECRET"))
+    seen: list[str] = []
+    monkeypatch.setattr(httpx, "Client", _mock(_setup_mcp_handler(seen, oauth_status=200)))
+
+    assert main(["setup", "mcp", "--json"]) == 0
+    out = capsys.readouterr().out
+    body = json.loads(out)
+
+    assert "/.well-known/oauth-protected-resource" in seen, "OAuth probe never fired"
+    server = body["mcpServers"]["deepsieve"]
+    assert server == {"url": "https://x.test/mcp"}, server
+    assert "uvx" not in out and "command" not in out, "took the stdio branch on a 200"
+    assert body["oauth_discovery"] == "confirmed", body
+
+
+def test_setup_mcp_falls_back_to_stdio_when_oauth_unconfigured(monkeypatch, capsys):
+    """A 404 on the discovery doc → the local stdio server, key from the env.
+
+    Reds against the pre-fix command, which emitted the HTTP `/mcp` URL
+    unconditionally regardless of what the deployment serves.
+    """
+    cfg.save_profile(cfg.Profile(name="default", origin="https://x.test", api_key="ds_live_SECRET"))
+    seen: list[str] = []
+    monkeypatch.setattr(httpx, "Client", _mock(_setup_mcp_handler(seen, oauth_status=404)))
+
+    assert main(["setup", "mcp", "--json"]) == 0
+    out = capsys.readouterr().out
+    body = json.loads(out)
+
+    assert "/.well-known/oauth-protected-resource" in seen, "OAuth probe never fired"
+    server = body["mcpServers"]["deepsieve"]
+    assert server["command"] == "uvx", server
+    assert server["args"] == ["deepsieve-mcp"], server
+    assert server["env"]["DEEPSIEVE_API_URL"] == "https://x.test", server
+    assert "url" not in server, "emitted the HTTP transport on a 404"
+    assert "ds_live_SECRET" not in out, "inlined the API key into the config snippet"
+    assert body["oauth_discovery"] == "absent", body
+
+
+def test_setup_mcp_marks_http_as_unverified_when_discovery_unreachable(monkeypatch, capsys):
+    """Unreachable discovery keeps the HTTP default (a network blip must not read
+    as "OAuth off") but MUST say so — "could not look" and a confirmed 200 must
+    never render identically (#1798). Asserts the uncertainty marker is present,
+    not merely that the HTTP snippet renders.
+    """
+    cfg.save_profile(cfg.Profile(name="default", origin="https://x.test", api_key="ds_live_SECRET"))
+    seen: list[str] = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen.append(request.url.path)
+        raise httpx.ConnectError("boom")  # the whole deployment is unreachable
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+
+    # --json: distinct marker, HTTP kept as the fallback (not stdio)
+    assert main(["setup", "mcp", "--json"]) == 0
+    body = json.loads(capsys.readouterr().out)
+    assert "/.well-known/oauth-protected-resource" in seen, "OAuth probe never fired"
+    assert body["mcpServers"]["deepsieve"] == {"url": "https://x.test/mcp"}, body
+    assert body["oauth_discovery"] == "unconfirmed", body
+
+    # human: HTTP snippet AND an explicit uncertainty line — not identical to a 200
+    assert main(["setup", "mcp"]) == 0
+    human = capsys.readouterr().out
+    assert "--transport http" in human, human
+    assert "Could not confirm" in human, "unverified default rendered as if confirmed"
+
+
+def test_setup_mcp_5xx_is_unconfirmed_not_absent(monkeypatch, capsys):
+    """A 5xx (e.g. a 503 deploy blip) is "could not determine", NOT "OAuth off".
+    Only the documented 404 is the definitive off-signal. A 5xx must render as
+    `unconfirmed`/HTTP, never as the categorical stdio "no browser login" — that
+    would relocate the found-nothing/could-not-look collapse to the 5xx boundary
+    (Seat A finding). Reds against a version that mapped every non-2xx to stdio.
+    """
+    cfg.save_profile(cfg.Profile(name="default", origin="https://x.test", api_key="ds_live_SECRET"))
+    seen: list[str] = []
+    monkeypatch.setattr(httpx, "Client", _mock(_setup_mcp_handler(seen, oauth_status=503)))
+
+    assert main(["setup", "mcp", "--json"]) == 0
+    body = json.loads(capsys.readouterr().out)
+    assert "/.well-known/oauth-protected-resource" in seen, "OAuth probe never fired"
+    assert body["oauth_discovery"] == "unconfirmed", body
+    server = body["mcpServers"]["deepsieve"]
+    assert server == {"url": "https://x.test/mcp"}, "a 5xx wrongly routed to stdio"
+
+
+def test_setup_mcp_human_output_matches_the_probe(monkeypatch, capsys):
+    """The human (non --json) output derives from the SAME probe, so the two
+    output modes can never advertise different transports (#1798 anti-drift)."""
+    cfg.save_profile(cfg.Profile(name="default", origin="https://x.test", api_key="ds_live_SECRET"))
+    seen: list[str] = []
+    monkeypatch.setattr(httpx, "Client", _mock(_setup_mcp_handler(seen, oauth_status=404)))
+
+    assert main(["setup", "mcp"]) == 0
+    out = capsys.readouterr().out
+    assert "/.well-known/oauth-protected-resource" in seen, "OAuth probe never fired"
+    assert "uvx deepsieve-mcp" in out, out
+    assert "--transport http" not in out, "advertised HTTP in human output on a 404"
+    assert "ds_live_SECRET" not in out, "printed the API key"
+
+
 def test_failed_run_exits_failure_not_success(monkeypatch):
     """README's table says 1 = failure; `runs get` consulted only `done`."""
     import httpx
@@ -505,3 +646,24 @@ def test_members_list_surfaces_a_scope_refusal_as_a_typed_error(monkeypatch, cap
     captured = capsys.readouterr()
     assert "insufficient_scope" in captured.err or "members:read" in captured.err
     assert "owner@example.com" not in captured.out
+
+
+def test_run_create_forwards_each_allowed_source(monkeypatch):
+    """#1802 — `--allowed-source` is repeatable and reaches the body as a list;
+    absent, the key is absent (the server applies the workspace default)."""
+    cfg.save_profile(cfg.Profile(name="default", origin="https://x.test", api_key="k"))
+    seen = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen["body"] = json.loads(request.content)
+        return httpx.Response(202, json={"id": "run_1", "status": "queued"})
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    assert main(["runs", "create", "--seeds", "Acme", "--dry-run",
+                 "--allowed-source", "*.gov", "--allowed-source", " dot.state.al.us "]) == 0
+    assert seen["body"]["allowed_sources"] == ["*.gov", "dot.state.al.us"]
+    assert main(["runs", "create", "--seeds", "Acme", "--dry-run"]) == 0
+    assert "allowed_sources" not in seen["body"]
+    # Only blanks → no key at all, never `[]` (the server refuses an empty list).
+    assert main(["runs", "create", "--seeds", "Acme", "--dry-run", "--allowed-source", " "]) == 0
+    assert "allowed_sources" not in seen["body"]