discolike-cli 0.3.0__tar.gz → 0.3.1__tar.gz

{discolike_cli-0.3.0 → discolike_cli-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: discolike-cli
-Version: 0.3.0
+Version: 0.3.1
 Summary: Official CLI for the DiscoLike API
 Project-URL: Homepage, https://www.discolike.com
 Project-URL: Documentation, https://docs.discolike.com
@@ -25,7 +25,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
-Requires-Dist: discolike==0.3.0
+Requires-Dist: discolike==0.3.1
 Requires-Dist: rich>=13.0
 Requires-Dist: typer>=0.12
 Description-Content-Type: text/markdown

{discolike_cli-0.3.0 → discolike_cli-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "discolike-cli"
-version = "0.3.0"
+version = "0.3.1"
 description = "Official CLI for the DiscoLike API"
 readme = "README.md"
 license = "MIT"
@@ -12,7 +12,7 @@ license-files = ["LICENSE"]
 requires-python = ">=3.10"
 authors = [{ name = "DiscoLike", email = "support@discolike.com" }]
 dependencies = [
-  "discolike==0.3.0",
+  "discolike==0.3.1",
   "typer>=0.12",
   "rich>=13.0",
 ]

{discolike_cli-0.3.0 → discolike_cli-0.3.1}/src/discolike_cli/auth.py

@@ -33,11 +33,12 @@ from discolike._oauth import OAuthError
 from discolike._oauth import build_authorization_url
 from discolike._oauth import discover
 from discolike._oauth import exchange_code
-from discolike._oauth import pkce_pair
 from discolike._oauth import register_client
 from discolike_cli._loopback import CallbackServer
 from discolike_cli._output import emit
 from discolike_cli._output import handle_errors
+from discolike_cli.signup import _is_interactive
+from discolike_cli.signup import run_signup
 
 app = typer.Typer(help="Manage credentials: log in (browser or API key), check status, log out.")
 
@@ -55,6 +56,10 @@ LOGIN_METHODS = (AUTH_METHOD_OAUTH, AUTH_METHOD_API_KEY)
 DEAD_CLIENT_ERRORS = frozenset({"invalid_client", "unauthorized_client"})
 
 
+HAS_ACCOUNT_PROMPT = "Do you already have a DiscoLike account?"
+SIGNUP_FOLLOWUP_MESSAGE = "Confirm the email, then run `discolike auth login` again to sign in."
+
+
 class _DeadClientError(Exception):
     """The authorization server no longer recognises the registered client_id."""
 
@@ -63,6 +68,23 @@ def _mask(key: str) -> str:
     return "…" + key[-MASKED_VISIBLE_CHARS:]
 
 
+def _was_passed_on_command_line(ctx: typer.Context, name: str) -> bool:
+    source = ctx.get_parameter_source(name)
+    return source is not None and source.name == "COMMANDLINE"
+
+
+def _offer_signup(ctx: typer.Context) -> None:
+    email = typer.prompt("Work email")
+    first_name = typer.prompt("First name")
+    last_name = typer.prompt("Last name")
+    base_url = str(ctx.obj.get("base_url") or DEFAULT_BASE_URL).rstrip("/")
+    run_signup(
+        email=email, first_name=first_name, last_name=last_name, agent=None, base_url=base_url, yes=False, fmt=None
+    )
+    typer.echo(SIGNUP_FOLLOWUP_MESSAGE)
+    raise typer.Exit(code=0)
+
+
 def _iso(epoch_seconds: float) -> str:
     return datetime.fromtimestamp(epoch_seconds, tz=timezone.utc).isoformat()
 
@@ -135,13 +157,11 @@ def _authorize(
     open_browser: bool,
     http: httpx2.Client,
 ) -> OAuthCredential:
-    verifier, challenge = pkce_pair()
     state = secrets.token_urlsafe(STATE_BYTES)
-    url = build_authorization_url(
+    url, verifier = build_authorization_url(
         metadata,
         client_id=registration.client_id,
         redirect_uri=registration.redirect_uri,
-        code_challenge=challenge,
         state=state,
         resource=resource,
     )
@@ -168,7 +188,6 @@ def _authorize(
             code_verifier=verifier,
             redirect_uri=registration.redirect_uri,
             resource=resource,
-            client=http,
         )
     except OAuthError as exc:
         if exc.error in DEAD_CLIENT_ERRORS:
@@ -230,6 +249,14 @@ def login(
     if method not in LOGIN_METHODS:
         raise typer.BadParameter(f"must be one of {', '.join(LOGIN_METHODS)}", param_hint="--method")
     global_key_passed = ctx.obj.get("api_key") is not None and _global_key_source(ctx) == SOURCE_OPTION
+    if (
+        _is_interactive()
+        and api_key is None
+        and not global_key_passed
+        and not _was_passed_on_command_line(ctx, "method")
+        and not typer.confirm(HAS_ACCOUNT_PROMPT, default=True)
+    ):
+        _offer_signup(ctx)
     if api_key or global_key_passed or method == AUTH_METHOD_API_KEY:
         _api_key_login(ctx, api_key=api_key)
         return

{discolike_cli-0.3.0 → discolike_cli-0.3.1}/src/discolike_cli/main.py

@@ -18,6 +18,7 @@ from discolike_cli import enrich
 from discolike_cli import match
 from discolike_cli import providers
 from discolike_cli import queries
+from discolike_cli import signup
 
 app = typer.Typer(
     name="discolike",
@@ -70,3 +71,4 @@ app.command(name="extract")(company.extract_command)
 app.command(name="validate-icp")(enrich.validate_icp_command)
 app.command(name="append")(enrich.append_command)
 app.command(name="segment")(enrich.segment_command)
+app.command(name="signup")(signup.signup_command)

discolike_cli-0.3.1/src/discolike_cli/signup.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import sys
+from importlib.metadata import version as package_version
+
+import typer
+
+from discolike._config import DEFAULT_BASE_URL
+from discolike._config import load_signup_email
+from discolike.signup import signup
+from discolike_cli._output import emit
+from discolike_cli._output import handle_errors
+
+FORMAT_HELP = "Output format: json or table (table auto-selected on a TTY; falls back to JSON for non-tabular data)."
+YES_HELP = "Skip the confirmation when signing up a different email than last time."
+CLI_AGENT = f"discolike-cli/{package_version('discolike-cli')}"
+
+
+def _is_interactive() -> bool:
+    return sys.stdin.isatty()
+
+
+def _confirm_email_change(previous: str, email: str, *, yes: bool) -> bool:
+    if yes:
+        return True
+    prompt = f"This machine already signed up {previous}. Sign up {email} as well?"
+    if _is_interactive():
+        return typer.confirm(prompt, default=False)
+    typer.echo(f"{prompt} re-run with --yes", err=True)
+    return False
+
+
+def run_signup(
+    *,
+    email: str,
+    first_name: str,
+    last_name: str,
+    agent: str | None,
+    base_url: str,
+    yes: bool,
+    fmt: str | None,
+) -> None:
+    previous = load_signup_email()
+    allow_new_email = False
+    if previous is not None and previous.lower() != email.lower():
+        if not _confirm_email_change(previous, email, yes=yes):
+            raise typer.Exit(code=1)
+        allow_new_email = True
+    emit(
+        signup(
+            email=email,
+            first_name=first_name,
+            last_name=last_name,
+            agent=agent or CLI_AGENT,
+            base_url=base_url,
+            allow_new_email=allow_new_email,
+        ),
+        fmt=fmt,
+    )
+
+
+@handle_errors
+def signup_command(
+    ctx: typer.Context,
+    email: str = typer.Option(..., "--email", help="The person's work email. Becomes the login."),
+    first_name: str = typer.Option(..., "--first-name"),
+    last_name: str = typer.Option(..., "--last-name"),
+    agent: str | None = typer.Option(None, "--agent", help="Agent or framework name to record with the signup."),
+    yes: bool = typer.Option(False, "--yes", "-y", help=YES_HELP),
+    fmt: str | None = typer.Option(None, "--format", help=FORMAT_HELP),
+) -> None:
+    """Create a DiscoLike account for a person. No login needed; they confirm by email."""
+    base_url = ctx.obj.get("base_url") or DEFAULT_BASE_URL
+    run_signup(
+        email=email, first_name=first_name, last_name=last_name, agent=agent, base_url=base_url, yes=yes, fmt=fmt
+    )

{discolike_cli-0.3.0 → discolike_cli-0.3.1}/tests/test_auth_oauth.py

@@ -7,6 +7,7 @@ import threading
 import time
 from collections.abc import Callable
 from typing import Any
+from unittest.mock import patch
 from urllib.parse import parse_qs
 from urllib.parse import urlparse
 from urllib.request import urlopen
@@ -75,18 +76,18 @@ class FakeProvider:
         self.register_calls.append(redirect_uris)
         return "client-1"
 
-    def exchange_code(self, metadata: AuthServerMetadata, *, client: httpx2.Client, **kwargs: Any) -> OAuthCredential:
+    def exchange_code(self, metadata: AuthServerMetadata, **kwargs: Any) -> OAuthCredential:
         self.exchange_calls.append(kwargs)
         if self.exchange_failures:
             raise self.exchange_failures.pop(0)
         return CREDENTIAL
 
-    def build_authorization_url(self, metadata: AuthServerMetadata, **kwargs: Any) -> str:
-        url = self.real_build_authorization_url(metadata, **kwargs)
+    def build_authorization_url(self, metadata: AuthServerMetadata, **kwargs: Any) -> tuple[str, str]:
+        url, verifier = self.real_build_authorization_url(metadata, **kwargs)
         query = {key: values[0] for key, values in parse_qs(urlparse(url).query).items()}
         callback = f"{query['redirect_uri']}?{self.callback_query(query)}"
         threading.Thread(target=lambda: urlopen(callback).read(), daemon=True).start()  # noqa: S310 -- loopback test server
-        return url
+        return url, verifier
 
     def open(self, url: str) -> bool:
         self.opened_urls.append(url)
@@ -170,7 +171,9 @@ def test_login_timeout_exits_1(
 ) -> None:
     install_build_client(_usage_ok)
     monkeypatch.setattr(auth_module, "LOGIN_TIMEOUT_SECONDS", 0.2)
-    monkeypatch.setattr(auth_module, "build_authorization_url", lambda metadata, **kwargs: "https://auth.test/never")
+    monkeypatch.setattr(
+        auth_module, "build_authorization_url", lambda metadata, **kwargs: ("https://auth.test/never", "v")
+    )
     result = runner.invoke(app, ["auth", "login"])
     assert result.exit_code == 1
     assert "Timed out" in json.loads(result.stderr.splitlines()[-1])["message"]
@@ -409,3 +412,86 @@ def test_login_forged_error_callback_cannot_evict_stored_client(
     assert "state mismatch" in json.loads(result.stderr.splitlines()[-1])["message"]
     assert provider.register_calls == []
     assert load_oauth_client() == registration
+
+
+def test_login_tty_confirms_existing_account_runs_oauth(
+    provider: FakeProvider,
+    install_build_client: Callable[[Handler], None],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    install_build_client(_usage_ok)
+    monkeypatch.setattr(auth_module, "_is_interactive", lambda: True)
+    with patch("discolike_cli.auth.run_signup", autospec=True) as run_signup_mock:
+        result = runner.invoke(app, ["auth", "login"], input="y\n")
+    assert result.exit_code == 0, result.output
+    assert provider.discover_calls == [DEFAULT_BASE_URL]
+    run_signup_mock.assert_not_called()
+
+
+def test_login_tty_declines_account_runs_signup(
+    provider: FakeProvider,
+    install_build_client: Callable[[Handler], None],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    install_build_client(_usage_ok)
+    monkeypatch.setattr(auth_module, "_is_interactive", lambda: True)
+    with patch("discolike_cli.auth.run_signup", autospec=True, return_value=None) as run_signup_mock:
+        result = runner.invoke(app, ["auth", "login"], input="n\njane@acme.com\nJane\nDoe\n")
+    assert result.exit_code == 0, result.output
+    run_signup_mock.assert_called_once_with(
+        email="jane@acme.com",
+        first_name="Jane",
+        last_name="Doe",
+        agent=None,
+        base_url=DEFAULT_BASE_URL,
+        yes=False,
+        fmt=None,
+    )
+    assert "run `discolike auth login` again" in result.output
+    assert provider.discover_calls == []
+
+
+def test_login_with_api_key_skips_account_question(install_build_client: Callable[[Handler], None]) -> None:
+    install_build_client(_usage_ok)
+    with patch("discolike_cli.auth.typer.confirm", autospec=True) as confirm_mock:
+        result = runner.invoke(app, ["auth", "login", "--api-key", "dk-1"])
+    assert result.exit_code == 0, result.output
+    confirm_mock.assert_not_called()
+
+
+def test_login_with_global_api_key_skips_account_question(
+    install_build_client: Callable[[Handler], None],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    install_build_client(_usage_ok)
+    monkeypatch.setattr(auth_module, "_is_interactive", lambda: True)
+    with patch("discolike_cli.auth.typer.confirm", autospec=True) as confirm_mock:
+        result = runner.invoke(app, ["--api-key", "dk-global", "auth", "login"])
+    assert result.exit_code == 0, result.output
+    confirm_mock.assert_not_called()
+    assert json.loads(config_path().read_text())["api_key"] == "dk-global"
+
+
+def test_login_with_explicit_api_key_method_skips_account_question(
+    install_build_client: Callable[[Handler], None],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    install_build_client(_usage_ok)
+    monkeypatch.setattr(auth_module, "_is_interactive", lambda: True)
+    with patch("discolike_cli.auth.typer.confirm", autospec=True) as confirm_mock:
+        result = runner.invoke(app, ["auth", "login", "--method", "api_key", "--api-key", "dk-x"])
+    assert result.exit_code == 0, result.output
+    confirm_mock.assert_not_called()
+    assert json.loads(config_path().read_text())["api_key"] == "dk-x"
+
+
+def test_login_rejects_unknown_method_on_a_tty_without_asking(
+    provider: FakeProvider,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(auth_module, "_is_interactive", lambda: True)
+    with patch("discolike_cli.auth.typer.confirm", autospec=True) as confirm_mock:
+        result = runner.invoke(app, ["auth", "login", "--method", "bogus"])
+    assert result.exit_code == 2
+    confirm_mock.assert_not_called()
+    assert provider.discover_calls == []

discolike_cli-0.3.1/tests/test_signup_cli.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import json
+from unittest.mock import patch
+
+from typer.testing import CliRunner
+
+from discolike._config import save_signup_email
+from discolike.signup import SignupResult
+from discolike_cli.main import app
+
+runner = CliRunner()
+
+_RESULT = SignupResult(
+    status="created",
+    email="jane@acme.com",
+    org_domain="acme.com",
+    org_status="created",
+    next_step="A confirmation email was sent to jane@acme.com.",
+)
+
+
+def test_signup_calls_sdk_without_client() -> None:
+    with patch("discolike_cli.signup.signup", autospec=True, return_value=_RESULT) as sdk_signup:
+        result = runner.invoke(
+            app, ["signup", "--email", "jane@acme.com", "--first-name", "Jane", "--last-name", "Doe"]
+        )
+    assert result.exit_code == 0, result.output
+    sdk_signup.assert_called_once()
+    kwargs = sdk_signup.call_args.kwargs
+    assert kwargs["email"] == "jane@acme.com"
+    assert kwargs["agent"].startswith("discolike-cli/")
+    assert json.loads(result.stdout)["next_step"] == _RESULT.next_step
+
+
+def test_signup_honours_base_url_option() -> None:
+    with patch("discolike_cli.signup.signup", autospec=True, return_value=_RESULT) as sdk_signup:
+        result = runner.invoke(
+            app,
+            [
+                "--base-url",
+                "https://api.dev.test/v1",
+                "signup",
+                "--email",
+                "j@acme.com",
+                "--first-name",
+                "J",
+                "--last-name",
+                "D",
+            ],
+        )
+    assert result.exit_code == 0, result.output
+    assert sdk_signup.call_args.kwargs["base_url"] == "https://api.dev.test/v1"
+
+
+def test_signup_does_not_require_credentials(monkeypatch) -> None:
+    monkeypatch.delenv("DISCOLIKE_API_KEY", raising=False)
+    with patch("discolike_cli.signup.signup", autospec=True, return_value=_RESULT):
+        result = runner.invoke(app, ["signup", "--email", "j@acme.com", "--first-name", "J", "--last-name", "D"])
+    assert result.exit_code == 0, result.output
+
+
+def test_signup_different_email_non_tty_exits_without_calling_sdk() -> None:
+    save_signup_email("jane@acme.com")
+    with patch("discolike_cli.signup.signup", autospec=True, return_value=_RESULT) as sdk_signup:
+        result = runner.invoke(
+            app, ["signup", "--email", "other@acme.com", "--first-name", "Other", "--last-name", "Person"]
+        )
+    assert result.exit_code == 1
+    sdk_signup.assert_not_called()
+    assert "re-run with --yes" in result.output
+
+
+def test_signup_different_email_with_yes_allows_new_email() -> None:
+    save_signup_email("jane@acme.com")
+    other_result = SignupResult(**{**_RESULT.to_dict(), "email": "other@acme.com"})
+    with patch("discolike_cli.signup.signup", autospec=True, return_value=other_result) as sdk_signup:
+        result = runner.invoke(
+            app,
+            ["signup", "--email", "other@acme.com", "--first-name", "Other", "--last-name", "Person", "--yes"],
+        )
+    assert result.exit_code == 0, result.output
+    assert sdk_signup.call_args.kwargs["allow_new_email"] is True
+
+
+def test_signup_different_email_tty_confirm_proceeds(monkeypatch) -> None:
+    save_signup_email("jane@acme.com")
+    monkeypatch.setattr("discolike_cli.signup._is_interactive", lambda: True)
+    other_result = SignupResult(**{**_RESULT.to_dict(), "email": "other@acme.com"})
+    with patch("discolike_cli.signup.signup", autospec=True, return_value=other_result) as sdk_signup:
+        result = runner.invoke(
+            app,
+            ["signup", "--email", "other@acme.com", "--first-name", "Other", "--last-name", "Person"],
+            input="y\n",
+        )
+    assert result.exit_code == 0, result.output
+    assert sdk_signup.call_args.kwargs["allow_new_email"] is True
+
+
+def test_signup_rejected_name_exits_nonzero_with_message_on_stderr() -> None:
+    result = runner.invoke(app, ["signup", "--email", "jane@acme.com", "--first-name", "Jane<b>", "--last-name", "Doe"])
+    assert result.exit_code != 0
+    payload = json.loads(result.stderr)
+    assert "must contain a letter and no angle brackets or control characters" in payload["message"]