atsfill 0.0.5.dev154__tar.gz → 0.0.5.dev160__tar.gz

{atsfill-0.0.5.dev154 → atsfill-0.0.5.dev160}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atsfill
-Version: 0.0.5.dev154
+Version: 0.0.5.dev160
 Summary: Read, dry-run and submit job application forms on hiring systems: Ashby, Greenhouse, Teamtailor, Welcome to the Jungle.
 Keywords: job-applications,ats,ashby,greenhouse,teamtailor,ai-agents,cli
 Author: shbernal
@@ -89,6 +89,7 @@ It is built for agents with a shell: every command prints one JSON document and
 [![workday run history](https://shbernal.github.io/atsfill/run-history/workday.svg)](https://shbernal.github.io/atsfill/run-history/)
 [![successfactors run history](https://shbernal.github.io/atsfill/run-history/successfactors.svg)](https://shbernal.github.io/atsfill/run-history/)
 [![isolvedhire run history](https://shbernal.github.io/atsfill/run-history/isolvedhire.svg)](https://shbernal.github.io/atsfill/run-history/)
+[![jobstreet run history](https://shbernal.github.io/atsfill/run-history/jobstreet.svg)](https://shbernal.github.io/atsfill/run-history/)
 [![gupy run history](https://shbernal.github.io/atsfill/run-history/gupy.svg)](https://shbernal.github.io/atsfill/run-history/)
 [![ukg run history](https://shbernal.github.io/atsfill/run-history/ukg.svg)](https://shbernal.github.io/atsfill/run-history/)
 <!-- /run-history -->

{atsfill-0.0.5.dev154 → atsfill-0.0.5.dev160}/README.md

@@ -60,6 +60,7 @@ It is built for agents with a shell: every command prints one JSON document and
 [![workday run history](https://shbernal.github.io/atsfill/run-history/workday.svg)](https://shbernal.github.io/atsfill/run-history/)
 [![successfactors run history](https://shbernal.github.io/atsfill/run-history/successfactors.svg)](https://shbernal.github.io/atsfill/run-history/)
 [![isolvedhire run history](https://shbernal.github.io/atsfill/run-history/isolvedhire.svg)](https://shbernal.github.io/atsfill/run-history/)
+[![jobstreet run history](https://shbernal.github.io/atsfill/run-history/jobstreet.svg)](https://shbernal.github.io/atsfill/run-history/)
 [![gupy run history](https://shbernal.github.io/atsfill/run-history/gupy.svg)](https://shbernal.github.io/atsfill/run-history/)
 [![ukg run history](https://shbernal.github.io/atsfill/run-history/ukg.svg)](https://shbernal.github.io/atsfill/run-history/)
 <!-- /run-history -->

{atsfill-0.0.5.dev154 → atsfill-0.0.5.dev160}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "atsfill"
-version = "0.0.5.dev154"
+version = "0.0.5.dev160"
 description = "Read, dry-run and submit job application forms on hiring systems: Ashby, Greenhouse, Teamtailor, Welcome to the Jungle."
 readme = "README.md"
 license = "MIT"

{atsfill-0.0.5.dev154 → atsfill-0.0.5.dev160}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "atsfill"
-version = "0.0.5.dev154"
+version = "0.0.5.dev160"
 description = "Read, dry-run and submit job application forms on hiring systems: Ashby, Greenhouse, Teamtailor, Welcome to the Jungle."
 readme = "README.md"
 license = "MIT"

{atsfill-0.0.5.dev154 → atsfill-0.0.5.dev160}/src/atsfill/adapters/__init__.py

@@ -10,6 +10,7 @@ from atsfill.adapters.hiringthing import HiringThing
 from atsfill.adapters.isolvedhire import IsolvedHire
 from atsfill.adapters.jazzhr import JazzHR
 from atsfill.adapters.jobaffinity import JobAffinity
+from atsfill.adapters.jobstreet import Jobstreet
 from atsfill.adapters.join import Join
 from atsfill.adapters.lever import Lever
 from atsfill.adapters.manatal import Manatal
@@ -68,6 +69,7 @@ def adapters() -> list[Adapter]:
         Gupy(),
         UKG(),
         IsolvedHire(),
+        Jobstreet(),
         SuccessFactors(),  # it claims a career site's job path on any host
         Phenom(),  # last: it claims a URL by its path alone
     ]

atsfill-0.0.5.dev160/src/atsfill/adapters/jobstreet.py

@@ -0,0 +1,481 @@
+"""Jobstreet and Jobsdb, SEEK's boards in Southeast Asia (`<country>.jobstreet.com/job/<id>`,
+`<country>.jobsdb.com/job/<id>`), as docs/adapters/jobstreet.md observes.
+
+Quick apply needs a SEEK account without a password, signed in by an emailed OTP on each site.
+The form is a wizard: documents and personal details, the employer's questions, the SEEK
+profile, then review. Each step is kept by the page until submit, so the read-back is each
+step's inputs as they stood when it was left.
+"""
+
+import re
+import time
+from contextlib import suppress
+from typing import Any
+from urllib.parse import urlsplit
+
+from atsfill.core import browser, matching, otp
+from atsfill.core.adapter import (
+    Blocked,
+    Gap,
+    NotTaken,
+    Refused,
+    SignedOut,
+    SignUpDetails,
+    Unsupported,
+    known_gap,
+)
+from atsfill.core.browser import Locator, Page, Request, Response, Timeout
+from atsfill.core.results import Answer, Field, FieldType, SideEffect
+
+HOST = re.compile(r"^(?:[a-z]{2})\.(?:jobstreet|jobsdb)\.com$")
+JOB = re.compile(r"^/(?:[a-z]{2}/)?job/(\d+)")
+SIGN_IN_HOST = "login.seek.com"
+APPLY = "[data-automation=job-detail-apply]"
+CONTINUE = "[data-testid=continue-button]"
+SUBMIT = "[data-testid=review-submit-application]"
+SAVE_DETAILS = "[data-automation=personal-details-save-button]"
+CHALLENGE = "Just a moment..."  # Cloudflare's interstitial: it passes on its own, or on a reload
+CHALLENGE_TRIES = 2
+SIGN_IN_TIMEOUT_MS = 90_000  # SEEK's sign-in takes up to ~50 s to show its form
+TURNSTILE_TIMEOUT_S = 45  # Cloudflare's widget passes on its own headless within seconds
+TURNSTILE_POLL_MS = 3_000
+OTP_STEP_TIMEOUT_MS = 30_000
+SIGNED_IN_TIMEOUT_MS = 60_000  # from the OTP typed to the site, through the OAuth redirects
+APPLY_TIMEOUT_MS = 60_000
+STEP_TIMEOUT_MS = 30_000
+SAVE_TIMEOUT_MS = 15_000
+SUBMIT_TIMEOUT_MS = 90_000
+CLICK_TRIES = 5
+STEP_MOVE_MS = 8_000  # from Continue to the next step's address, when the click was taken
+RERENDER_MS = 1_000
+STEP_ERRORS = "[role=alert]:has-text('please address')"
+SUGGEST_TIMEOUT_S = 8
+POLL_MS = 250
+KEY_DELAY_MS = 40
+DETAILS = ("firstName", "lastName", "currentLocation", "phone")
+VISIBILITY = ["Public", "Standard", "Limited", "Hidden"]
+
+_STEP_ONE = """() => {
+  const value = sel => document.querySelector(sel)?.value ?? null;
+  const code = document.querySelector('#countryCallingCode');
+  const picked = name => [...document.querySelectorAll(`input[type=radio][name^="${name}"]`)]
+    .find(e => e.checked);
+  const label = e => e && document.querySelector(`label[for="${e.id}"]`)?.innerText.trim();
+  const resume = picked('document-select');
+  const letter = document.querySelector('[data-testid=coverLetter-method-change]');
+  const phone = value('#phoneNumber');
+  return {
+    firstName: value('#firstName'), lastName: value('#lastName'),
+    currentLocation: value('#currentLocation2'),
+    phone: phone && code?.value
+      ? `${code.options[code.selectedIndex].text.match(/\\+\\d+/)?.[0] ?? ''}${phone}` : null,
+    resume: resume && resume.value !== 'dont-include' ? label(resume) : null,
+    coverLetter: letter?.checked ? value('[data-testid=coverLetterTextInput]') : null,
+  };
+}"""
+
+_QUESTIONS = """() => {
+  const out = {};
+  for (const s of document.querySelectorAll('select[name^="questionnaire."]')) {
+    out[s.name] = s.value ? s.options[s.selectedIndex].text.trim() : null;
+  }
+  for (const e of document.querySelectorAll('input[name^="questionnaire."]:checked')) {
+    const text = document.querySelector(`label[for="${e.id}"]`)?.innerText.trim() ?? e.value;
+    if (e.type === 'radio') out[e.name] = text;
+    else (out[e.name] ??= []).push(text);
+  }
+  return out;
+}"""
+
+
+class Jobstreet:
+    name = "jobstreet"
+    per_employer = True  # one SEEK account, signed in on each site apart: the scope is the site
+    asks: set[str] = set()
+    known_gaps = {"profile_incomplete": Gap.FLOW}
+    side_effects = [
+        SideEffect("sign_up", "hiring_system", "login --create creates the SEEK account"),
+        SideEffect("fill", "hiring_system", "the personal details are saved to the SEEK profile"),
+        SideEffect("upload", "hiring_system", "a resume is stored as the SEEK profile's default"),
+        SideEffect("submit", "employer", "the application and the SEEK profile reach the employer"),
+    ]
+
+    def __init__(self) -> None:
+        self._fields: dict[str, Field] = {}
+        self._read: dict[str, Answer] = {}
+
+    def detect(self, url: str, page: Page | None) -> bool:
+        parts = urlsplit(url)
+        return bool(HOST.match(parts.hostname or "")) and bool(JOB.match(parts.path))
+
+    def posting(self, url: str) -> str:
+        parts = urlsplit(url)
+        match = JOB.match(parts.path)
+        return f"https://{parts.hostname}/job/{match[1]}" if match else url
+
+    def account_scope(self, url: str) -> str:
+        return urlsplit(url).hostname or ""
+
+    def login_url(self, scope: str | None) -> str:
+        return f"https://{scope}/oauth/login?returnUrl=%2F"
+
+    def signed_in(self, request: Request, scope: str | None) -> bool:
+        """The site's `/profile` redirects an account to `/profile/me` and shows a visitor its
+        page. Cloudflare answers 403 outside the browser, so a session there reads signed out."""
+        response = request.get(f"https://{scope}/profile", max_redirects=0)
+        return response.status in (302, 307) and response.headers.get("location", "").endswith(
+            "/profile/me"
+        )
+
+    def sign_in_by_otp(self, page: Page, email: str) -> None:
+        _sign_in(page, email, create=False)
+
+    def sign_up_by_otp(self, page: Page, email: str, details: SignUpDetails) -> None:
+        _sign_in(page, email, create=True)
+
+    def browser_read(self, page: Page) -> list[Field]:
+        """Opens Quick apply; the questions and the account's details come from the GraphQL
+        answers the page loads with. An Apply that links out has no form here."""
+        job = JOB.match(urlsplit(page.url).path)
+        if not job:
+            raise RuntimeError(f"{page.url} is not a Jobstreet job")
+        apply = page.locator(APPLY).first
+        for attempt in range(CHALLENGE_TRIES):  # a check held once passed on the next load
+            try:
+                apply.wait_for(timeout=APPLY_TIMEOUT_MS)
+                break
+            except Timeout:
+                if page.title() != CHALLENGE:
+                    raise RuntimeError("the posting shows no Apply button") from None
+                if attempt == CHALLENGE_TRIES - 1:
+                    raise Blocked("captcha: Cloudflare's check kept the posting") from None
+                page.reload()
+        if apply.get_attribute("target") == "_blank":  # Apply, not Quick apply: `isLinkOut`
+            raise Unsupported("external_step: the job applies on the employer's site")
+        host = urlsplit(page.url).hostname
+        answers: dict[str, Any] = {}
+
+        def on_response(response: Response) -> None:
+            if urlsplit(response.url).path == "/graphql":
+                answers.update(_operations(response))
+
+        page.on("response", on_response)
+        try:
+            page.goto(f"https://{host}/job/{job[1]}/apply")
+            _opened(page)
+            deadline = time.monotonic() + STEP_TIMEOUT_MS / 1000
+            needed = {"GetPersonalDetails", "GetJobApplicationProcess", "GetUser"}
+            while not needed <= answers.keys() and time.monotonic() < deadline:
+                page.wait_for_timeout(POLL_MS)
+        finally:
+            page.remove_listener("response", on_response)
+        if not needed <= answers.keys():
+            raise RuntimeError(
+                f"the apply page loaded without {', '.join(needed - answers.keys())}"
+            )
+        process = answers["GetJobApplicationProcess"]["jobApplicationProcess"]
+        if process.get("linkOut"):
+            raise Unsupported("external_step: the job applies on the employer's site")
+        viewer = answers["GetPersonalDetails"]["viewer"]
+        fields = _documents(page, viewer) + [
+            f
+            for q in (process.get("questionnaire") or {}).get("questions") or []
+            if (f := _question(q))
+        ]
+        if answers["GetUser"]["viewer"].get("profileVisibility2") is None:
+            fields.append(Field("profileVisibility", "Profile visibility", FieldType.CHOICE, True,
+                                VISIBILITY))  # fmt: skip
+        self._fields = {f.id: f for f in fields}
+        self._read = {}
+        return fields
+
+    def fill(self, page: Page, answers: dict[str, Answer]) -> None:
+        """Walks the steps in order, each answered and left with Continue, which stays put with
+        its errors while one is missing; the review step takes the profile's visibility."""
+        self._read = {k: f.prefilled for k in DETAILS if (f := self._fields[k]).prefilled}
+        self._read |= _personal_details(page, self._fields, answers)
+        _documents_fill(page, answers)
+        documents = page.evaluate(_STEP_ONE)
+        self._read |= {k: documents[k] for k in ("resume", "coverLetter") if documents[k]}
+        _continue(page)
+        if page.url.split("?")[0].endswith("/role-requirements"):
+            for field_id, answer in answers.items():
+                if field_id.startswith("question."):
+                    _answer(page, self._fields[field_id], answer)
+            asked = page.evaluate(_QUESTIONS)
+            self._read |= {
+                f"question.{name.removeprefix('questionnaire.')}": value
+                for name, value in asked.items()
+                if value
+            }
+            _continue(page)
+        if page.url.split("?")[0].endswith("/profile"):
+            try:
+                _continue(page)
+            except NotTaken as e:
+                if "career history" not in str(e).lower():
+                    raise
+                reason = known_gap(self, "profile_incomplete", "the profile has no career history")
+                raise Unsupported(reason) from None
+        if "profileVisibility" in answers:
+            radio = page.locator(
+                f"[data-testid=profile-visibility-field2-radio-group-"
+                f"{str(answers['profileVisibility']).lower()}]"
+            )
+            radio.check(force=True)
+            if radio.is_checked():
+                self._read["profileVisibility"] = radio.get_attribute("value") or ""
+
+    def read_back(self, page: Page) -> dict[str, Answer]:
+        return dict(self._read)
+
+    def submit(self, page: Page) -> str | None:
+        review = page.url
+        browser.click(page.locator(SUBMIT))
+        try:
+            page.wait_for_url(lambda url: url != review, timeout=SUBMIT_TIMEOUT_MS)
+        except Timeout:
+            raise RuntimeError("Submit application left the review step in place") from None
+        return f"Submit application moved to {urlsplit(page.url).path}"
+
+
+def _opened(page: Page) -> None:
+    """Waits for the wizard's first step. A session the site ended itself (its tokens refused)
+    sends the page to SEEK's sign-in instead, though `/profile` still holds it."""
+    deadline = time.monotonic() + APPLY_TIMEOUT_MS / 1000
+    while time.monotonic() < deadline:
+        if page.locator(CONTINUE).is_visible():
+            return
+        if urlsplit(page.url).hostname == SIGN_IN_HOST:
+            with suppress(Timeout):  # its redirects done: a navigation meanwhile is aborted
+                page.get_by_label("Email address").wait_for(timeout=SIGN_IN_TIMEOUT_MS)
+            raise SignedOut("login_required: the site sent Quick apply to SEEK's sign-in")
+        page.wait_for_timeout(POLL_MS)
+    raise RuntimeError("Quick apply showed no first step")
+
+
+def _sign_in(page: Page, email: str, create: bool) -> None:
+    """SEEK's sign-in: the email, Cloudflare's widget, then the OTP it emails, typed in six
+    digits that send themselves. An email without an account lands on "Register a new account?",
+    where only a sign-up goes on."""
+    box = page.get_by_label("Email address")
+    try:
+        box.wait_for(timeout=SIGN_IN_TIMEOUT_MS)
+    except Timeout:
+        raise Unsupported(f"unhandled_rendering: no SEEK sign-in on {page.url}") from None
+    box.fill(email)
+    code = page.get_by_label("verification input")
+    deadline = time.monotonic() + TURNSTILE_TIMEOUT_S
+    while not code.count():
+        if time.monotonic() > deadline:
+            raise Blocked("captcha: SEEK's sign-in kept asking to complete the recaptcha")
+        page.get_by_role("button", name="Email me a sign in code").click()
+        try:  # clicked before the widget passed, the page says so and sends nothing
+            code.wait_for(timeout=TURNSTILE_POLL_MS)
+        except Timeout:
+            if not page.get_by_text("complete the recaptcha").count():
+                code.wait_for(timeout=OTP_STEP_TIMEOUT_MS)
+    otp.enter(code, email, "SEEK's sign-in")
+    try:
+        page.wait_for_url(
+            lambda url: (
+                "signin-confirmation" in url
+                or (urlsplit(url).hostname != SIGN_IN_HOST and "/oauth" not in urlsplit(url).path)
+            ),
+            timeout=SIGNED_IN_TIMEOUT_MS,
+        )
+    except Timeout:
+        raise Blocked(f"otp_rejected: SEEK's sign-in sent an OTP to {email}") from None
+    if "signin-confirmation" not in page.url:
+        return
+    if not create:
+        raise Refused("no_account")
+    page.locator("#privacy-chkbox").check(force=True)  # the marketing box stays unticked
+    page.get_by_role("button", name="Register new account").click()
+    page.wait_for_url(
+        lambda url: "/oauth" not in urlsplit(url).path and "/sign-in/" not in urlsplit(url).path,
+        timeout=SIGNED_IN_TIMEOUT_MS,
+    )
+
+
+def _operations(response: Response) -> dict[str, Any]:
+    """The `data` of each operation a GraphQL response answers, by operation name."""
+    try:
+        sent, answered = response.request.post_data_json, response.json()
+    except Exception:
+        return {}
+    pairs = zip(*(x if isinstance(x, list) else [x] for x in (sent, answered)), strict=False)
+    return {
+        s["operationName"]: a["data"]
+        for s, a in pairs
+        if isinstance(s, dict) and isinstance(a, dict) and a.get("data")
+    }
+
+
+def _documents(page: Page, viewer: dict[str, Any]) -> list[Field]:
+    """The first step: the profile's personal details, then the resume and the cover letter,
+    optional where the page offers to leave them out."""
+    details = viewer["personalDetails"]
+    code = (details.get("countryCallingCode") or {}).get("countryCallingCode", "")
+    location = (viewer.get("currentLocation2") or {}).get("description")
+    resume = page.locator("input[type=file][id^=resume]")
+    accept: list[str] | None = None
+    if resume.count():
+        accept = [str(a) for a in (resume.get_attribute("accept") or "").split(",")]
+    return [
+        Field("firstName", "First name", FieldType.TEXT, True,
+              prefilled=details.get("firstName") or None),
+        Field("lastName", "Last name", FieldType.TEXT, True,
+              prefilled=details.get("lastName") or None),
+        Field("currentLocation", "Home location", FieldType.TYPEAHEAD, True, prefilled=location),
+        Field("phone", "Phone number", FieldType.PHONE, False,
+              prefilled=f"{code}{details['phoneNumber']}" if details.get("phoneNumber") else None),
+        Field("resume", "Resumé", FieldType.FILE,
+              not page.locator("input[type=radio][value=dont-include]").count(), accept=accept),
+        Field("coverLetter", "Cover letter", FieldType.TEXT,
+              not page.locator("[data-testid=coverLetter-method-none]").count()),
+    ]  # fmt: skip
+
+
+def _question(raw: dict[str, Any]) -> Field | None:
+    field_id, label = f"question.{raw['id']}", raw["text"]
+    options = [o["text"] for o in raw.get("options") or []]
+    match raw["__typename"]:
+        case "SingleChoiceQuestion":
+            return Field(field_id, label, FieldType.CHOICE, True, options)
+        case "MultipleChoiceQuestion":
+            return Field(field_id, label, FieldType.MULTI_CHOICE, True, options)
+        case "PrivacyPolicyQuestion":
+            return Field(field_id, label, FieldType.CHOICE, True, options)
+    reason = f"unhandled_rendering: {label!r} is a {raw['__typename']}"
+    return Field(field_id, label, FieldType.TEXT, True, unfillable=reason)
+
+
+def _personal_details(
+    page: Page, fields: dict[str, Field], answers: dict[str, Answer]
+) -> dict[str, Answer]:
+    """Types the details that differ from the profile's, then saves them to it: the step goes
+    no further while the details are open, whether changed or not. Returns what was saved."""
+    changed = {
+        k: v for k in DETAILS
+        if (v := answers.get(k)) is not None and v != fields[k].prefilled
+    }  # fmt: skip
+    if changed and not page.locator("#firstName").is_visible():
+        raise Unsupported("unhandled_rendering: the personal details show no inputs")
+    for key, selector in (("firstName", "#firstName"), ("lastName", "#lastName")):
+        if key in changed:
+            page.locator(selector).fill(str(changed[key]))
+    if "currentLocation" in changed:
+        _suggest(page, fields["currentLocation"], page.locator("#currentLocation2"),
+                 str(changed["currentLocation"]))  # fmt: skip
+    if "phone" in changed:
+        _phone(page, str(changed["phone"]))
+    save = page.locator(SAVE_DETAILS)
+    if not save.is_visible():
+        return {}
+    saved = {k: v for k, v in page.evaluate(_STEP_ONE).items() if k in DETAILS and v}
+    save.click()
+    try:
+        save.wait_for(state="hidden", timeout=SAVE_TIMEOUT_MS)
+    except Timeout:
+        said = page.locator("[id$=-message]").all_inner_texts()
+        raise NotTaken(f"the personal details were not saved: {'; '.join(said)}") from None
+    return saved
+
+
+def _phone(page: Page, answer: str) -> None:
+    """Picks the country whose calling code starts the E.164 answer, the longest one, then
+    types the rest."""
+    codes = page.locator("#countryCallingCode").evaluate(
+        "s => [...s.options].map(o => [o.value, o.text.match(/\\+\\d+/)?.[0]])"
+    )
+    picked = max(
+        ((value, code) for value, code in codes if code and answer.startswith(code)),
+        key=lambda c: len(c[1]),
+        default=None,
+    )
+    if picked is None:
+        raise NotTaken(f"no country calling code starts {answer!r}")
+    page.locator("#countryCallingCode").select_option(picked[0])
+    page.locator("#phoneNumber").fill(answer.removeprefix(picked[1]))
+
+
+def _documents_fill(page: Page, answers: dict[str, Answer]) -> None:
+    """Uploads the resume, which the page then picks, or leaves it out; the same for the cover
+    letter, written in its box."""
+    if (resume := answers.get("resume")) is not None:
+        page.locator("input[type=file][id^=resume]").set_input_files(str(resume))
+        name = str(resume).rsplit("/", 1)[-1]
+        page.locator("label", has_text=name).first.wait_for(timeout=SAVE_TIMEOUT_MS)
+    elif (none := page.locator("input[type=radio][value=dont-include]")).count():
+        none.check(force=True)
+    if (letter := answers.get("coverLetter")) is not None:
+        page.locator("[data-testid=coverLetter-method-change]").check(force=True)
+        page.locator("[data-testid=coverLetterTextInput]").fill(str(letter))
+    elif (none := page.locator("[data-testid=coverLetter-method-none]")).count():
+        none.check(force=True)
+
+
+def _answer(page: Page, field: Field, answer: Answer) -> None:
+    name = f"questionnaire.{field.id.removeprefix('question.')}"
+    select = page.locator(f'select[name="{name}"]')
+    if select.count():
+        select.select_option(label=str(answer))
+        return
+    boxes = page.locator(f'input[name="{name}"]')
+    if not boxes.count():
+        raise Unsupported(f"unhandled_rendering: {field.id} shows no select or boxes")
+    wanted = answer if isinstance(answer, list) else [answer]
+    for box in boxes.all():
+        label = page.locator(f'label[for="{box.get_attribute("id")}"]')
+        text = label.inner_text().strip()
+        wanted_here = any(matching.matches(field, str(w), text) for w in wanted)
+        if box.get_attribute("type") == "radio" and not wanted_here:
+            continue
+        if box.is_checked() != wanted_here:  # the input is styled away: its label takes the click
+            browser.click(label)
+        if box.is_checked() != wanted_here:
+            raise NotTaken(f"{field.id} did not take {text!r}")
+
+
+def _continue(page: Page) -> None:
+    """Continue, once the next step's address shows; the step's errors otherwise. The profile
+    step re-renders as its queries come back, losing a click: one that moves nothing and says
+    nothing is clicked again."""
+    step = page.url
+    page.wait_for_load_state("networkidle", timeout=STEP_TIMEOUT_MS)
+    for _ in range(CLICK_TRIES):
+        try:
+            browser.click(page.locator(CONTINUE))
+            page.wait_for_url(lambda url: url != step, timeout=STEP_MOVE_MS)
+            break
+        except browser.BrowserError as e:  # a Timeout too
+            if not isinstance(e, Timeout) and "not attached" not in str(e):
+                raise
+            if page.locator(STEP_ERRORS).count():
+                break
+            page.wait_for_timeout(RERENDER_MS)
+    if page.url == step:
+        said = " ".join(page.locator("[role=alert]").all_inner_texts()).strip()
+        raise NotTaken(f"Continue stayed on {urlsplit(step).path}: {said}")
+    page.locator(f"{CONTINUE}, {SUBMIT}").first.wait_for(timeout=STEP_TIMEOUT_MS)
+    # a step renders its inputs once its queries answer, and takes no Continue before
+    page.wait_for_load_state("networkidle", timeout=STEP_TIMEOUT_MS)
+    if page.url.split("?")[0].endswith("/role-requirements"):
+        page.locator('[name^="questionnaire."]').first.wait_for(timeout=STEP_TIMEOUT_MS)
+
+
+def _suggest(page: Page, field: Field, box: Locator, answer: str) -> None:
+    """Types the answer key by key, which loads the suggestions, and picks the one that
+    matches it: a typed location the page does not take."""
+    box.fill("")
+    box.press_sequentially(answer, delay=KEY_DELAY_MS)
+    options = page.locator("[role=option]:visible")
+    deadline = time.monotonic() + SUGGEST_TIMEOUT_S
+    while time.monotonic() < deadline:
+        for option in options.all():
+            if matching.matches(field, answer, option.inner_text().strip()):
+                option.click()
+                return
+        page.wait_for_timeout(POLL_MS)
+    raise NotTaken(f"no suggestion for {answer!r} in {field.id}")

{atsfill-0.0.5.dev154 → atsfill-0.0.5.dev160}/src/atsfill/adapters/join.py

@@ -3,12 +3,16 @@
 Applying is a wizard of one step per page, ending on a review page whose Confirm & apply is the
 send. Signed in, the wizard takes the name from the account and asks the CV, a cover letter and
 the job's screening questions, which the page's own GraphQL query lists. The fill walks the
-steps to the review page, and the read-back is what the review page lists.
+steps to the review page, and the read-back is what the review page lists. What the wizard takes
+from the account (name, phone, country, city, links) is the account profile's, a form of one
+profile step that `profile` saves (ADR 0017).
 """
 
 import json
 import re
 import time
+from collections.abc import Callable
+from dataclasses import replace
 from typing import Any
 from urllib.parse import urlsplit
 
@@ -17,10 +21,10 @@ from atsfill.core.adapter import (
     Blocked,
     Gap,
     NotTaken,
+    ProfileIncomplete,
     Refused,
     SignUpDetails,
     Unsupported,
-    known_gap,
 )
 from atsfill.core.browser import Locator, Page, Request, Response, Timeout
 from atsfill.core.results import Answer, Field, FieldType, SideEffect
@@ -31,7 +35,13 @@ ME = f"https://{HOST}/api/me"
 GRAPHQL = f"https://{HOST}/candidate-api/graphql"
 LOGIN = f"https://{HOST}/auth/login/candidate?redirectUrl=%2Ftalent%2Fhome"
 UNVERIFIED = "/auth/candidates/unverified-email"
+PROFILE = f"https://{HOST}/talent/me?edit=profile"
+GENERAL = "general"  # the account profile's one profile step
 STEP_TIMEOUT_MS = 20_000
+PROFILE_TIMEOUT_MS = 20_000
+SAVE_TIMEOUT_MS = 20_000
+MENU_TIMEOUT_MS = 5_000
+SUGGEST_TIMEOUT_MS = 10_000  # the city's suggestions come from a request per search
 UPLOAD_TIMEOUT_MS = 30_000
 ACCOUNT_TIMEOUT_MS = 20_000
 SUBMIT_TIMEOUT_MS = 60_000
@@ -57,8 +67,27 @@ CLASS_STEPS = {
     "availability": "AVAILABILITY",
 }
 PROFILE_STEPS = ("personalInformation", "professionalLinks")  # the account profile's
+# What a wizard's profile step can ask that the account profile lacks, by input id.
+LACKS = {
+    "candidate.firstName": "a first name",
+    "candidate.lastName": "a last name",
+    "candidate.phoneNumber": "a phone",
+}
 PDF = [".pdf", "application/pdf"]
 
+# The profile form's controls, by its field ids.
+TEXTS = {
+    "first_name": "candidate.firstName",
+    "last_name": "candidate.lastName",
+    "linkedin": "professionalLinks.LINKEDIN",
+}
+COUNTRY = '[id="candidate.countryId"]'
+CITY = "[data-testid=CityName]"
+PHONE = '[id="candidate.phoneNumber"]'
+DIAL = "[data-phone-input] button"  # the phone's country code, a popover of countries
+POPOVER = "[data-scope=popover][data-part=content]"
+DIAL_CODE = re.compile(r"\(\+(\d+)\)\s*$")  # an option of the popover: `France (+33)`
+
 # The page's own GraphQL request, from the page.
 _FETCH = """async ([url, body]) => (await fetch(url, {method: "POST", body: JSON.stringify(body),
   headers: {"content-type": "application/json"}})).json()"""
@@ -70,14 +99,26 @@ _REVIEW = """() => [...document.querySelectorAll("a > div")].map(div => {
     ? [label.textContent.trim(), value.textContent.trim()] : null;
 }).filter(Boolean)"""
 
+# A select's value: the paragraph it shows, not an option of its open menu.
+_SHOWN = """root => {
+  const p = [...root.querySelectorAll("p")].find(p => !p.closest("[role=option]"));
+  return p ? p.textContent.trim() : "";
+}"""
+
+# The ids of the inputs that are empty, of those given.
+_EMPTY = (
+    """ids => ids.filter(id => { const e = document.getElementById(id); return e && !e.value; })"""
+)
+
 
 class Join:
     name = "join"
     per_employer = False
     asks = {"name"}  # the account's first and last name
-    known_gaps = {"profile_incomplete": Gap.FLOW}
+    known_gaps: dict[str, Gap] = {}
     side_effects = [
         SideEffect("sign_up", "hiring_system", "login --create creates the candidate account"),
+        SideEffect("profile", "hiring_system", "profile --answers saves the account profile"),
         SideEffect("upload", "hiring_system", "a file is stored as soon as it is chosen"),
         SideEffect("submit", "employer", "the application reaches the employer"),
     ]
@@ -196,9 +237,11 @@ class Join:
             elif step in PROFILE_STEPS:
                 try:  # shown when the job requires what the account profile lacks
                     _next(page, step)
-                except NotTaken, RuntimeError:
-                    detail = f"the {step} step asks what the account profile lacks"
-                    raise Unsupported(known_gap(self, "profile_incomplete", detail)) from None
+                except NotTaken, RuntimeError:  # Continue disabled, or refused on click
+                    lacks = [LACKS[i] for i in page.evaluate(_EMPTY, list(LACKS))]
+                    raise ProfileIncomplete(
+                        f"the job asks for {' and '.join(lacks) or f'what {step} asks'}"
+                    ) from None
                 continue
             else:
                 raise Unsupported(f"unhandled_rendering: a wizard step {step!r}")
@@ -239,6 +282,83 @@ class Join:
             return f"POST {parts.path}?{parts.query} {response.status}"
         raise RuntimeError(f"POST {response.url} answered {response.status}: {body.get('errors')}")
 
+    def profile_url(self, scope: str | None) -> str:
+        return PROFILE
+
+    def profile_steps(self, page: Page) -> list[str]:
+        return [GENERAL]
+
+    def open_step(self, page: Page, step: str) -> bool:
+        if step != GENERAL:
+            raise Unsupported(f"unhandled_rendering: a profile step {step!r}")
+        if page.url != PROFILE:
+            page.goto(PROFILE)
+        page.locator(f'[id="{TEXTS["first_name"]}"]').wait_for(timeout=PROFILE_TIMEOUT_MS)
+        return True
+
+    def profile_read(self, page: Page) -> list[Field]:
+        """The general information form: the name, the phone, the country and city of residence
+        and the LinkedIn URL. The photo, the bio, the work authorizations and the other links are
+        left as they are, as are the profile's other sections (experience, education, …)."""
+        saved = self.profile_read_back(page)
+        limit = {
+            k: int(page.locator(f'[id="{i}"]').get_attribute("maxlength") or 0) or None
+            for k, i in TEXTS.items()
+        }
+        fields = [
+            Field("first_name", "First name", FieldType.TEXT, True, max_length=limit["first_name"]),
+            Field("last_name", "Last name", FieldType.TEXT, True, max_length=limit["last_name"]),
+            Field("phone", "Phone number, with its country code", FieldType.PHONE, False),
+            Field("country", "Country of residence", FieldType.CHOICE, True, _menu(page, COUNTRY)),
+            Field("city", "City, in the country of residence", FieldType.TYPEAHEAD, False),
+            Field("linkedin", "LinkedIn", FieldType.URL, False),
+        ]  # fmt: skip
+        return [replace(f, prefilled=saved.get(f.id)) for f in fields]
+
+    def profile_fill(self, page: Page, answers: dict[str, Answer]) -> None:
+        """In the form's order: the city is searched in the country of residence."""
+        for field_id, input_id in TEXTS.items():
+            if isinstance(answer := answers.get(field_id), str):
+                page.locator(f'[id="{input_id}"]').fill(answer)
+        if isinstance(answer := answers.get("phone"), str):
+            _phone(page, answer)
+        if isinstance(answer := answers.get("country"), str):
+            _pick(page, COUNTRY, answer, lambda text: text == answer, MENU_TIMEOUT_MS)
+        if isinstance(answer := answers.get("city"), str):
+            _pick(page, CITY, answer, lambda text: True, SUGGEST_TIMEOUT_MS)
+
+    def profile_read_back(self, page: Page) -> dict[str, Answer]:
+        values = {k: page.locator(f'[id="{i}"]').input_value() for k, i in TEXTS.items()}
+        phone = page.locator(PHONE)
+        if phone.input_value():  # `data-value` holds the country code and the number
+            values["phone"] = phone.get_attribute("data-value") or ""
+        values["country"] = _shown(page, COUNTRY)
+        values["city"] = _shown(page, CITY)
+        return {k: v for k, v in values.items() if v}
+
+    def save(self, page: Page) -> None:
+        """Save changes posts `UpdateTalentPersonalInformation`; the button stays disabled while
+        a required field is empty or nothing changed."""
+        button = page.locator("form button[type=submit]").last
+        try:  # it is enabled a moment after the last change
+            page.wait_for_function(
+                "e => !e.disabled", arg=button.element_handle(), timeout=BUTTON_TIMEOUT_MS
+            )
+        except Timeout:
+            raise Refused(
+                f"step_refused: {GENERAL}: the form keeps its Save button disabled"
+            ) from None
+        with page.expect_response(
+            lambda r: "operationName=UpdateTalentPersonalInformation" in r.url,
+            timeout=SAVE_TIMEOUT_MS,
+        ) as sent:
+            button.click()
+        response = sent.value
+        if not response.ok:
+            raise RuntimeError(f"UpdateTalentPersonalInformation answered {response.status}")
+        if errors := response.json().get("errors"):
+            raise Refused(f"step_refused: {GENERAL}: {errors[0].get('message')}")
+
     def _file(self, page: Page, field_id: str, answer: Answer | None) -> None:
         if not isinstance(answer, str):
             return
@@ -348,6 +468,62 @@ def _date(page: Page, answer: str) -> None:
     (trigger if trigger.count() else day.first).click()
 
 
+def _select(page: Page, container: str) -> tuple[Locator, Locator]:
+    """A select of the profile form: its combobox, and the options its menu shows, whose ids
+    carry the combobox's."""
+    box = page.locator(container).locator("input[role=combobox]")
+    suffix = (box.get_attribute("id") or "").removeprefix("select-input-")
+    return box, page.locator(f'[id^="react-select-{suffix}-option-"]')
+
+
+def _menu(page: Page, container: str) -> list[str]:
+    box, options = _select(page, container)
+    box.click()
+    options.first.wait_for(timeout=MENU_TIMEOUT_MS)
+    texts = [t.strip() for t in options.all_inner_texts()]
+    box.press("Escape")
+    return texts
+
+
+def _pick(page: Page, container: str, answer: str, take: Callable[[str], bool], ms: int) -> None:
+    """Searches the select for the answer and picks the first option `take` accepts."""
+    box, options = _select(page, container)
+    box.click()
+    box.fill(answer)
+    try:
+        options.first.wait_for(timeout=ms)
+    except Timeout:
+        raise NotTaken(f"no option for {answer!r}") from None
+    texts = [t.strip() for t in options.all_inner_texts()]
+    picked = next((i for i, text in enumerate(texts) if take(text)), None)
+    if picked is None:
+        raise NotTaken(f"no option {answer!r} in {texts}")
+    options.nth(picked).click()
+
+
+def _shown(page: Page, container: str) -> str:
+    """A select's value as it shows, empty under its placeholder."""
+    return page.locator(container).first.evaluate(_SHOWN)
+
+
+def _phone(page: Page, answer: str) -> None:
+    """Picks the country whose code starts the answer, the longest of them, then types the rest:
+    the number's input takes digits only."""
+    digits = re.sub(r"\D", "", answer)
+    if not answer.strip().startswith("+"):
+        raise NotTaken(f"the phone {answer!r} has no country code, `+<code> <number>`")
+    page.locator(DIAL).click()
+    options = page.locator(POPOVER).locator("[role=option]")
+    options.first.wait_for(timeout=MENU_TIMEOUT_MS)
+    codes = [m[1] if (m := DIAL_CODE.search(t)) else "" for t in options.all_inner_texts()]
+    starting = [i for i, code in enumerate(codes) if code and digits.startswith(code)]
+    if not starting:
+        raise NotTaken(f"no country code starts the phone {answer!r}")
+    picked = max(starting, key=lambda i: len(codes[i]))
+    options.nth(picked).click()
+    page.locator(PHONE).fill(digits[len(codes[picked]) :])
+
+
 def _email_step(page: Page, email: str) -> bool:
     """The account page's first step: the email. Whether an account has it, from what the page
     asks next: a password alone for one, a name and a password for none."""

{atsfill-0.0.5.dev154 → atsfill-0.0.5.dev160}/src/atsfill/core/adapter.py

@@ -15,6 +15,14 @@ class Blocked(Exception):
     """
 
 
+class SignedOut(Blocked):
+    """The system's page asks to sign in although `signed_in` found the session holding: the
+    system ended it its own way. The core signs in again and reads once more (ADR 0015).
+
+    The message is `login_required: detail`.
+    """
+
+
 class Unsupported(Exception):
     """What stops the form before any fill: a flow the adapter does not handle, or a fact about
     the posting (`posting_gone`, `external_step`). The message is `code: detail`.

{atsfill-0.0.5.dev154 → atsfill-0.0.5.dev160}/src/atsfill/core/browser.py

@@ -283,9 +283,16 @@ def login_window(data_dir: Path, url: str, headless: bool = False) -> Generator[
 
 
 def save_session(page: Page, path: Path) -> None:
+    """Stores the context's cookies and each origin's storage; the cookies alone where Firefox
+    aborts gathering an origin's storage (a sign-in that framed a Cloudflare challenge)."""
     path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
     path.touch(mode=0o600)
-    page.context.storage_state(path=path)
+    try:
+        page.context.storage_state(path=path)
+    except BrowserError as e:
+        if "NS_ERROR_ABORT" not in str(e):
+            raise
+        path.write_text(json.dumps({"cookies": page.context.cookies(), "origins": []}))
 
 
 @contextmanager

{atsfill-0.0.5.dev154 → atsfill-0.0.5.dev160}/src/atsfill/core/commands.py

@@ -1,6 +1,7 @@
 import shlex
 from collections.abc import Callable, Generator
 from contextlib import contextmanager, suppress
+from contextvars import ContextVar
 from dataclasses import dataclass
 from importlib.metadata import version
 from pathlib import Path
@@ -31,6 +32,7 @@ from atsfill.core.adapter import (
     ProfileIncomplete,
     ReadsByRequest,
     Refused,
+    SignedOut,
     SignsIn,
     SignsInByOtp,
     SignUpDetails,
@@ -182,12 +184,40 @@ def _opened(
             return
         scope = adapter.account_scope(url) if isinstance(adapter, NeedsAccount) else None
         with otp.source(user, adapter.name, scope):
-            if isinstance(adapter, NeedsAccount) and not (
-                session and adapter.signed_in(page.request, scope)
-            ):
-                yield _sign_in_again(page, adapter, user, mine, url, credentials) or (page, adapter)
-            else:
+            if not isinstance(adapter, NeedsAccount):
                 yield page, adapter
+                return
+            token = _again.set(lambda: _sign_in_again(page, adapter, user, mine, url, None))
+            try:
+                if not (session and adapter.signed_in(page.request, scope)):
+                    yield _sign_in_again(page, adapter, user, mine, url, credentials) or (
+                        page,
+                        adapter,
+                    )
+                else:
+                    yield page, adapter
+            finally:
+                _again.reset(token)
+            if session:  # a system that rotates the session's tokens as the page uses them
+                with suppress(Exception):
+                    browser.save_session(page, session)
+
+
+_again: ContextVar[Callable[[], Result | None] | None] = ContextVar("again", default=None)
+
+
+def _read_signed_in(page: Page, adapter: Adapter) -> list[Field]:
+    """`browser_read`, once more after signing in again where the page asked to sign in although
+    the session held: the result that ends the command instead is raised as `Blocked`."""
+    try:
+        return adapter.browser_read(page)
+    except SignedOut:
+        again = _again.get()
+        if again is None:
+            raise
+        if ended := again():
+            raise Blocked(ended.reason) from None
+        return adapter.browser_read(page)
 
 
 def _sign_in_again(
@@ -338,7 +368,7 @@ def _fill(page: Page, adapter: Adapter, url: str, answers: dict[str, Answer], us
     """Fills and reads back; `ready` when every answer reads back as given."""
     result = _result(adapter, url, user)
     with _stops(result):
-        _listed(result, adapter.browser_read(page))
+        _listed(result, _read_signed_in(page, adapter))
         if _unfillable(result, answers):
             return result
         if problems := matching.problems(result.fields, answers):
@@ -363,7 +393,7 @@ def _browser_read(data: Path, user: str, url: str, sessions: Sessions | None, se
         def run() -> Result:
             result = _result(adapter, url, user)
             with _stops(result):
-                _listed(result, adapter.browser_read(page))
+                _listed(result, _read_signed_in(page, adapter))
                 _unfillable(result)
             _profile_incomplete(result, adapter, user, url)
             return result

{atsfill-0.0.5.dev154 → atsfill-0.0.5.dev160}/src/atsfill/core/registry.py

@@ -160,7 +160,8 @@ def backlog(registry: dict[str, Source] | None = None) -> str:
     text = [
         "# Hiring systems",
         "",
-        "Generated from [src/atsfill/registry.toml](../../src/atsfill/registry.toml) by"
+        "Generated from [src/atsfill/registry.toml]"
+        "(https://github.com/shbernal/atsfill/blob/main/src/atsfill/registry.toml) by"
         " `uv run python -m scripts.backlog`. The registry is described in"
         " [ADR 0012](../adr/0012-systems-registry.md), the order in"
         " [ADR 0013](../adr/0013-survey-and-adapter-rounds.md): no account first, blocked and"

{atsfill-0.0.5.dev154 → atsfill-0.0.5.dev160}/src/atsfill/registry.toml

@@ -321,10 +321,11 @@ scope = { is = "supported", date = 2026-10-26, commit = "867de7d" }
 [jobstreet]
 kind = "board"
 share = 0.0047
-account = "to_read"  # Apply needs a SEEK account; its sign-in and sign-up have no password, an emailed OTP alone each time
+account = "to_read"  # Apply needs a SEEK account without a password, signed in by an emailed OTP on each site
 hosting = ["hosted"]
 hosts = ["jobstreet.com", "jobsdb.com"]
-scope = { is = "in_scope", date = 2026-10-26, reason = "unsupported_flow: sign_in_otp_only: Apply goes to the SEEK sign-in, with no password, every sign-in and sign-up a six-digit OTP emailed to the address, alone (14 of 15 employers)" }
+adapter = "jobstreet"
+scope = { is = "supported", date = 2026-10-29, commit = "49a997e" }
 
 [whatjobs-uk]
 kind = "aggregator"