Files
rickandCursor 20ed62b963 Sign in via Cognito directly so PerfectDraft gets the domain
PerfectDraft's Cognito PreAuthentication Lambda now requires a "domain"
field in ClientMetadata. The api.perfectdraft.com /authentication/sign-in
gateway does not forward it, so every setup and reauth failed with
"PreAuthentication failed with error 'domain'" (#11, #12, #13).
authenticate() now calls Cognito InitiateAuth (USER_PASSWORD_AUTH)
itself, the endpoint token refresh already uses.

A failed sign-in now says what was rejected and why. A wrong email or
password returns to the credentials form; a rejected token stays on the
token step; both show Cognito's reason instead of the old blanket "token
may have expired", which hid this outage.

The README snippet copies the token to the clipboard. It captures copy()
up front because Chromium removes it once the console command returns.

Root cause and fix by @cesa030 in #11; confirmed in @brettjenkins' fork.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-07 11:20:47 +01:00

259 lines
8.8 KiB
Python

"""Config flow for PerfectDraft integration."""
from __future__ import annotations
import logging
from typing import Any
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import CONF_EMAIL, CONF_PASSWORD
from homeassistant.core import callback
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from .api import PerfectDraftApiClient
from .const import (
CONF_ACCESS_TOKEN,
CONF_ID_TOKEN,
CONF_MACHINE_ID,
CONF_REFRESH_TOKEN,
CONF_SCAN_INTERVAL,
DEFAULT_SCAN_INTERVAL,
DOMAIN,
MIN_SCAN_INTERVAL,
)
from .exceptions import (
AuthenticationError,
PerfectDraftApiError,
PerfectDraftConnectionError,
)
_LOGGER = logging.getLogger(__name__)
CONF_RECAPTCHA_TOKEN = "recaptcha_token"
_AUTH_ERRORS = {
"credentials": "invalid_credentials",
"token": "token_rejected",
"other": "invalid_auth",
}
class PerfectDraftConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
"""Handle a config flow for PerfectDraft."""
VERSION = 1
def __init__(self) -> None:
self._email: str | None = None
self._password: str | None = None
# Fills {reason} in the error strings; every form must pass it.
self._auth_reason = ""
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> config_entries.ConfigFlowResult:
"""Step 1: collect email and password."""
if user_input is not None:
self._email = user_input[CONF_EMAIL]
self._password = user_input[CONF_PASSWORD]
return await self.async_step_token()
return self._show_user_form({})
def _show_user_form(
self, errors: dict[str, str]
) -> config_entries.ConfigFlowResult:
return self.async_show_form(
step_id="user",
data_schema=vol.Schema(
{
vol.Required(CONF_EMAIL): str,
vol.Required(CONF_PASSWORD): str,
}
),
errors=errors,
description_placeholders={"reason": self._auth_reason},
)
async def async_step_token(
self, user_input: dict[str, Any] | None = None
) -> config_entries.ConfigFlowResult:
"""Step 2: collect reCAPTCHA token from user."""
errors: dict[str, str] = {}
if user_input is not None:
recaptcha_token = user_input[CONF_RECAPTCHA_TOKEN].strip()
session = async_get_clientsession(self.hass)
client = PerfectDraftApiClient(session)
try:
await client.authenticate(
self._email, self._password, recaptcha_token
)
except AuthenticationError as err:
_LOGGER.error("Authentication failed: %s", err)
self._auth_reason = err.display_reason
error = _AUTH_ERRORS[err.kind]
if error == "invalid_credentials":
# A fresh token cannot fix a wrong password, so ask for
# the credentials again instead of looping on this step.
if self.source == config_entries.SOURCE_REAUTH:
return self._show_reauth_confirm_form({"base": error})
return self._show_user_form({"base": error})
errors["base"] = error
except PerfectDraftConnectionError as err:
_LOGGER.error("Connection failed: %s", err)
errors["base"] = "cannot_connect"
except PerfectDraftApiError as err:
_LOGGER.error("API error during auth: %s", err)
errors["base"] = "unknown"
else:
reauth_entry = (
self._get_reauth_entry()
if self.source == config_entries.SOURCE_REAUTH
else None
)
machine_id = (
reauth_entry.data.get(CONF_MACHINE_ID) if reauth_entry else None
)
if machine_id:
return await self._async_persist(
client, reauth_entry, machine_id
)
try:
profile = await client.get_user_profile()
except (PerfectDraftApiError, PerfectDraftConnectionError):
errors["base"] = "cannot_connect"
else:
return await self._async_persist(
client, reauth_entry, _extract_machine_id(profile)
)
return self.async_show_form(
step_id="token",
data_schema=vol.Schema(
{
vol.Required(CONF_RECAPTCHA_TOKEN): str,
}
),
errors=errors,
description_placeholders={"reason": self._auth_reason},
)
async def _async_persist(
self,
client: PerfectDraftApiClient,
reauth_entry: config_entries.ConfigEntry | None,
machine_id: str | None,
) -> config_entries.ConfigFlowResult:
"""Store the freshly issued tokens.
Reauth must update the entry it was started for. Creating a new one
would change the entry_id and orphan every entity's unique_id, and
`_abort_if_unique_id_configured` cannot be used here at all: during
reauth the unique ID belongs to that very entry, so the duplicate
guard would abort the flow and discard the new tokens.
"""
data = {
CONF_ACCESS_TOKEN: client.access_token,
CONF_ID_TOKEN: client.id_token,
CONF_REFRESH_TOKEN: client.refresh_token,
CONF_MACHINE_ID: machine_id,
}
await self.async_set_unique_id(self._email.lower())
if reauth_entry is not None:
self._abort_if_unique_id_mismatch(reason="reauth_account_mismatch")
return self.async_update_reload_and_abort(
reauth_entry, data_updates=data
)
self._abort_if_unique_id_configured()
return self.async_create_entry(
title=f"PerfectDraft ({self._email})",
data={CONF_EMAIL: self._email, **data},
)
async def async_step_reauth(
self, entry_data: dict[str, Any]
) -> config_entries.ConfigFlowResult:
"""Handle re-authentication when the refresh token expires."""
self._email = entry_data.get(CONF_EMAIL)
return await self.async_step_reauth_confirm()
async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None
) -> config_entries.ConfigFlowResult:
"""Ask user to re-enter credentials for reauth."""
if user_input is not None:
self._email = user_input[CONF_EMAIL]
self._password = user_input[CONF_PASSWORD]
return await self.async_step_token()
return self._show_reauth_confirm_form({})
def _show_reauth_confirm_form(
self, errors: dict[str, str]
) -> config_entries.ConfigFlowResult:
return self.async_show_form(
step_id="reauth_confirm",
data_schema=vol.Schema(
{
vol.Required(CONF_EMAIL, default=self._email): str,
vol.Required(CONF_PASSWORD): str,
}
),
errors=errors,
description_placeholders={"reason": self._auth_reason},
)
@staticmethod
@callback
def async_get_options_flow(
config_entry: config_entries.ConfigEntry,
) -> PerfectDraftOptionsFlow:
return PerfectDraftOptionsFlow(config_entry)
class PerfectDraftOptionsFlow(config_entries.OptionsFlow):
"""Handle options for PerfectDraft (polling interval)."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
self._config_entry = config_entry
async def async_step_init(
self, user_input: dict[str, Any] | None = None
) -> config_entries.ConfigFlowResult:
if user_input is not None:
interval = max(user_input[CONF_SCAN_INTERVAL], MIN_SCAN_INTERVAL)
return self.async_create_entry(
title="", data={CONF_SCAN_INTERVAL: interval}
)
current = self._config_entry.options.get(
CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL
)
return self.async_show_form(
step_id="init",
data_schema=vol.Schema(
{
vol.Required(CONF_SCAN_INTERVAL, default=current): vol.All(
int, vol.Range(min=MIN_SCAN_INTERVAL)
),
}
),
)
def _extract_machine_id(profile: dict[str, Any]) -> str | None:
"""Extract the first machine ID from the /api/me response."""
machines = profile.get("perfectdraftMachines")
if isinstance(machines, list) and machines:
return str(machines[0].get("id", ""))
return None