atsfill 0.0.4.dev134__tar.gz → 0.0.4.dev136__tar.gz

{atsfill-0.0.4.dev134 → atsfill-0.0.4.dev136}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atsfill
-Version: 0.0.4.dev134
+Version: 0.0.4.dev136
 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
@@ -137,6 +137,7 @@ A dry run or a `send` through an adapter no send was verified on carries a `warn
 
 One home can send for more than one user: `--user <name>` gives each their own sessions, double-send guard and `[users.<name>]` section in the config file ([ADR 0015](docs/adr/0015-users-and-accounts.md)).
 Given an account's email (`atsfill login <adapter> --email`) and a password source (a `[password-commands]` entry such as `rbw get example.com {email}`, or `--password -` on stdin), atsfill signs in by itself, and again whenever a form command finds the session signed out.
+When a system emails an OTP, on a sign-in, a sign-up or a form, atsfill gets it from the user's `[otp-commands]` entry, a command that reads the mailbox (`{email}` and `{since}` are filled in), and types it in; without one the command ends `blocked: no_otp_command`.
 Where a system's sign-up allows it, `atsfill login <adapter> --create --email <address>` (with `--details <file.json>` where the sign-up asks the user's name, phone or address) creates the account with a password atsfill generates and keeps in the system's secret store, never printed; creating an account is a side effect, never part of `fill` or `send`.
 
 ## How it works

{atsfill-0.0.4.dev134 → atsfill-0.0.4.dev136}/README.md

@@ -109,6 +109,7 @@ A dry run or a `send` through an adapter no send was verified on carries a `warn
 
 One home can send for more than one user: `--user <name>` gives each their own sessions, double-send guard and `[users.<name>]` section in the config file ([ADR 0015](docs/adr/0015-users-and-accounts.md)).
 Given an account's email (`atsfill login <adapter> --email`) and a password source (a `[password-commands]` entry such as `rbw get example.com {email}`, or `--password -` on stdin), atsfill signs in by itself, and again whenever a form command finds the session signed out.
+When a system emails an OTP, on a sign-in, a sign-up or a form, atsfill gets it from the user's `[otp-commands]` entry, a command that reads the mailbox (`{email}` and `{since}` are filled in), and types it in; without one the command ends `blocked: no_otp_command`.
 Where a system's sign-up allows it, `atsfill login <adapter> --create --email <address>` (with `--details <file.json>` where the sign-up asks the user's name, phone or address) creates the account with a password atsfill generates and keeps in the system's secret store, never printed; creating an account is a side effect, never part of `fill` or `send`.
 
 ## How it works

{atsfill-0.0.4.dev134 → atsfill-0.0.4.dev136}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "atsfill"
-version = "0.0.4.dev134"
+version = "0.0.4.dev136"
 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.4.dev134 → atsfill-0.0.4.dev136}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "atsfill"
-version = "0.0.4.dev134"
+version = "0.0.4.dev136"
 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.4.dev134 → atsfill-0.0.4.dev136}/src/atsfill/adapters/greenhouse.py

@@ -14,9 +14,9 @@ from contextlib import suppress
 from typing import Any
 from urllib.parse import parse_qs, urlencode, urlsplit
 
-from atsfill.core import browser
-from atsfill.core.adapter import Gap, Unsupported
-from atsfill.core.browser import HTTP_TIMEOUT_S, Page, Timeout
+from atsfill.core import browser, otp
+from atsfill.core.adapter import Blocked, Gap, Unsupported
+from atsfill.core.browser import HTTP_TIMEOUT_S, BrowserError, Page, Timeout
 from atsfill.core.results import Answer, Field, FieldType, SideEffect
 
 HOSTS = re.compile(r"^(job-boards|boards)(\.eu)?\.greenhouse\.io$")
@@ -33,6 +33,7 @@ HYDRATE_TIMEOUT_MS = 15_000
 FORM_TIMEOUT_MS = 20_000
 ANSWER_TIMEOUT_MS = 15_000  # an upload's file name, a suggestion: past it, a mismatch
 SUBMIT_TIMEOUT_MS = 90_000
+SUBMIT_POLL_MS = 500  # for the confirmation or the OTP step
 HYDRATE_POLL_MS = 500  # for a select's list to open, per click
 KEY_DELAY_MS = 20
 API_TYPES = {
@@ -43,6 +44,11 @@ API_TYPES = {
     "multi_value_multi_select": FieldType.MULTI_CHOICE,
 }
 YES_NO = ["Yes", "No"]
+CONFIRMATION = re.compile(r"/confirmation")
+# The OTP step a submit can stop at: a box per character of the OTP it emails.
+OTP_STEP = "fieldset#email-verification"
+OTP_INPUTS = f"{OTP_STEP} input[id^='security-input-']"
+OTP_ERROR = "#email-verification-error"
 # Sections the page adds or names its own way, or shows a question of only on another answer
 # (EEOC race after Hispanic/Latino): `request_read` declines a posting with any (ADR 0011).
 UNMAPPED = ("education", "compliance", "demographic_questions")
@@ -234,8 +240,24 @@ class Greenhouse:
         return {k: v for k, v in values.items() if v not in (None, "", [])}
 
     def submit(self, page: Page) -> str | None:
-        browser.click(page.locator(f"{FORM} button[type=submit]"))
-        page.wait_for_url(re.compile(r"/confirmation"), timeout=SUBMIT_TIMEOUT_MS)
+        """Submits, then types the emailed OTP where the step asks for one and submits again.
+        The evidence is the confirmation page."""
+        button = page.locator(f"{FORM} button[type=submit]")
+        browser.click(button)
+        if not _confirmed(page, OTP_INPUTS):
+            email = page.locator(f"{FORM} {_by_id('email')}").input_value()
+            otp.enter(page.locator(OTP_INPUTS), email, "the submit")
+            browser.click(button)
+            try:
+                confirmed = _confirmed(page, OTP_ERROR)
+            except Timeout:
+                if not page.locator(f"{OTP_INPUTS}:visible").count():
+                    raise
+                stayed = "unhandled_rendering: the submit stayed at the OTP step"
+                raise Unsupported(stayed) from None
+            if not confirmed:
+                message = page.locator(OTP_ERROR).first.inner_text().strip()
+                raise Blocked(f"otp_rejected: the submit did not take the OTP: {message}")
         return page.url
 
     def _field(self, page: Page, raw: dict[str, Any]) -> Field:
@@ -317,6 +339,19 @@ def _wait_until_live(page: Page) -> None:
         return
 
 
+def _confirmed(page: Page, step: str) -> bool:
+    """True once the page reaches the confirmation, False once `step` shows instead."""
+    deadline = time.monotonic() + SUBMIT_TIMEOUT_MS / 1000
+    while time.monotonic() < deadline:
+        with suppress(BrowserError):  # the page navigating away
+            if CONFIRMATION.search(page.url):
+                return True
+            if page.locator(f"{step}:visible").count():
+                return False
+        page.wait_for_timeout(SUBMIT_POLL_MS)
+    raise Timeout(f"no confirmation within {SUBMIT_TIMEOUT_MS} ms")
+
+
 def _board_job(url: str) -> tuple[str, str] | None:
     """The board and job id of a board URL: `/<board>/jobs/<id>` or `embed/job_app?for&token`."""
     parts = urlsplit(url)

{atsfill-0.0.4.dev134 → atsfill-0.0.4.dev136}/src/atsfill/adapters/isolvedhire.py

@@ -173,7 +173,6 @@ class IsolvedHire:
     per_employer = False
     asks = {"name", "phone", "street", "city", "state", "zip", "country"}
     known_gaps = {
-        "sign_up_otp": Gap.FLOW,  # why the sign-up goes through the sign-in, not Apply now
         "entry_list": Gap.RENDERING,
         "drawn_signature": Gap.RENDERING,
     }

{atsfill-0.0.4.dev134 → atsfill-0.0.4.dev136}/src/atsfill/adapters/oracle.py

@@ -2,8 +2,9 @@
 as docs/adapters/oracle.md observes.
 
 The form opens only past an email step, and an email the employer's Oracle already knows gets an
-emailed OTP instead. Reading passes the step with a throwaway address; filling starts over with
-the answer's. Oracle keeps a draft of the application from then on, autosaved as fields change.
+emailed OTP first, typed in by the core. Reading passes the step with a throwaway address;
+filling starts over with the answer's. Oracle keeps a draft of the application from then on,
+autosaved as fields change.
 """
 
 import re
@@ -15,7 +16,7 @@ from pathlib import PurePath
 from typing import Any
 from urllib.parse import urlsplit
 
-from atsfill.core import browser, matching
+from atsfill.core import browser, matching, otp
 from atsfill.core.adapter import Blocked, Gap, NotTaken, Unsupported, known_gap
 from atsfill.core.browser import Locator, Page
 from atsfill.core.results import Answer, Field, FieldType, Is, OptionSet, SideEffect
@@ -32,9 +33,12 @@ PAGINATION = ".apply-flow-pagination__button"
 PAGE_NUMBERS = ".apply-flow-navigation-pages__link:visible"
 LOADING = ".app-loading-spinner, .cx-select--loading, .apply-flow-block .skeleton"
 OTP_PAGE = ".apply-flow-pin-code-required"
+PIN = f"{OTP_PAGE} .pin-code-input__input"  # one per digit
+VERIFY = f"{OTP_PAGE} button[type=submit]"
 CAPTCHA = "iframe[src*='hcaptcha.com']"
 MANUALLY = ".quick-apply-flow__manually--link:visible"  # past an offer to import a profile
 ATTACHED = ".attachment-upload-button__download, .misc-attachment-list__item-name"
+REMOVE = ".attachment-upload-button__filled .attachment-upload-button__bottom-button"
 STEP_TIMEOUT_MS = 30_000
 LIST_TIMEOUT_MS = 3_000
 SEARCH_TIMEOUT_MS = 6_000  # for a typed search's results
@@ -356,21 +360,26 @@ class Oracle:
             if "--checked" not in (box.get_attribute("class") or ""):
                 _click(page, box)
         _click(page, page.locator(NEXT).first)
-        opened = page.locator(f"apply-flow-block, {OTP_PAGE}, {MANUALLY}")
         try:
-            opened.first.wait_for(timeout=STEP_TIMEOUT_MS)
-            if page.locator(MANUALLY).count():
-                _click(page, page.locator(MANUALLY).first)
-                page.locator("apply-flow-block").first.wait_for(timeout=STEP_TIMEOUT_MS)
+            page.locator(f"apply-flow-block, {OTP_PAGE}, {MANUALLY}").first.wait_for(
+                timeout=STEP_TIMEOUT_MS
+            )
         except browser.Timeout:
             if page.locator(CAPTCHA).count():
                 raise Blocked("captcha: the email step asks for an hCaptcha") from None
             raise RuntimeError("the email step did not open the form") from None
-        if page.locator(OTP_PAGE).count():
-            raise Blocked(
-                f"email_otp: {email} is known to this employer's Oracle, which emails it an"
-                " OTP before it shows the form"
-            )
+        if page.locator(OTP_PAGE).count():  # an address this employer's Oracle knows
+            otp.enter(page.locator(PIN), email, "the email step")
+            _click(page, page.locator(VERIFY))
+            try:
+                page.locator(f"apply-flow-block, {MANUALLY}").first.wait_for(
+                    timeout=STEP_TIMEOUT_MS
+                )
+            except browser.Timeout:
+                raise Blocked("otp_rejected: the email step did not take the OTP") from None
+        if page.locator(MANUALLY).count():
+            _click(page, page.locator(MANUALLY).first)
+            page.locator("apply-flow-block").first.wait_for(timeout=STEP_TIMEOUT_MS)
         page.locator(f"{PAGINATION}:visible").first.wait_for(timeout=STEP_TIMEOUT_MS)
         _settle(page)
 
@@ -428,6 +437,11 @@ class Oracle:
             return
         if kind == "file":
             assert isinstance(answer, str)
+            # a draft from an earlier visit keeps its file, the input gone until it is removed
+            remove = page.locator(f"{_upload(field_id)} {REMOVE}")
+            if remove.count():
+                _click(page, remove.first)
+                self._file_input(page, field_id).wait_for(state="attached", timeout=STEP_TIMEOUT_MS)
             self._file_input(page, field_id).set_input_files(answer)
             return
         row = self._row(page, field_id)

{atsfill-0.0.4.dev134 → atsfill-0.0.4.dev136}/src/atsfill/adapters/successfactors.py

@@ -13,6 +13,7 @@ from pathlib import Path
 from typing import Any
 from urllib.parse import parse_qs, urlsplit
 
+from atsfill.core import otp
 from atsfill.core.adapter import (
     Blocked,
     Gap,
@@ -26,7 +27,9 @@ from atsfill.core.browser import Locator, Page, PageRequest, Request, Timeout
 from atsfill.core.results import Answer, Field, FieldType, SideEffect
 
 JOB = re.compile(r"^(?:/[^/]+)?/job/[^/]+/(?P<id>\d{5,})/?$")
-DC_HOST = re.compile(r"^career\d*\.(?:sapsf|successfactors)\.(?:eu|com|cn)$")
+DC_HOST = re.compile(
+    r"^(?:career\d*\.(?:sapsf|successfactors)\.(?:eu|com|cn)|career-[a-z]+\d*\.ns2cloud\.com)$"
+)
 APPLY = "a[href*='/talentcommunity/apply/']"
 COMPANY_COOKIE = "careerSiteCompanyId"
 PROFILE = "/career?company={company}&career_ns=job_listing_summary&navBarLevel=MY_PROFILE"
@@ -43,6 +46,7 @@ COUNTRY = "fbclc_country"  # its options' values are ISO 3166 alpha-2 codes
 PHONE, CALLING_CODE = "#fbclc_phoneNumber", "#fbclc_ituCode"  # `CA`: `Canada (+1)`
 SIGN_UP = "#fbclc_userName"
 PASSCODE = "#passcode"  # an OTP some sign-ups ask before the account exists
+PASSCODE_STEP = "#otpContainer"
 QUICK_APPLY = "#fbqa_apply"
 FORM = ".RCMFormField"
 LANDED = f"{SIGN_IN}, {SIGN_UP}, {FORM}"
@@ -243,7 +247,9 @@ class SuccessFactors:
             if page.locator(FORM).count():
                 return
             if page.locator(f"{PASSCODE}:visible").count():
-                raise Blocked("email_otp: the sign-up sent a passcode to the email")
+                self._passcode(page, email)
+                deadline = time.monotonic() + SIGN_IN_TIMEOUT_MS / 1000
+                continue
             if not page.locator(f"{SIGN_UP}:visible").count():
                 break
             if self._message(page, REFUSAL):
@@ -265,6 +271,16 @@ class SuccessFactors:
             return
         raise Unsupported(f"unhandled_rendering: the sign-up led to {urlsplit(page.url).path}")
 
+    def _passcode(self, page: Page, email: str) -> None:
+        """Types the passcode the sign-up emailed; the account exists once it is taken."""
+        otp.enter(page.locator(PASSCODE), email, "the sign-up")
+        page.locator(PASSCODE_STEP).get_by_role("button").first.click()
+        try:
+            page.locator(PASSCODE).wait_for(state="hidden", timeout=SIGN_IN_TIMEOUT_MS)
+        except Timeout:
+            message = self._message(page)
+            raise Blocked(f"otp_rejected: the sign-up did not take the OTP: {message}") from None
+
     def browser_read(self, page: Page) -> list[Field]:
         self._candidate(page)
         if not page.locator(FORM).count():

{atsfill-0.0.4.dev134 → atsfill-0.0.4.dev136}/src/atsfill/core/adapter.py

@@ -120,8 +120,8 @@ class SignsIn(NeedsAccount, Protocol):
 
     def sign_in(self, page: Page, email: str, password: str) -> None:
         """Signs in on the page `login_url` loaded. Raises `Blocked` for what the system waits
-        for (`email_link`, `email_otp`, `sms_otp`, `captcha`), `Refused` for what it turns down,
-        `Unsupported` for a page it does not know."""
+        for (`email_link`, `email_otp`, `sms_otp`, `captcha`, the OTP command's reasons),
+        `Refused` for what it turns down, `Unsupported` for a page it does not know."""
         ...
 
 

{atsfill-0.0.4.dev134 → atsfill-0.0.4.dev136}/src/atsfill/core/commands.py

@@ -11,6 +11,7 @@ from atsfill.core import (
     browser,
     conditions,
     matching,
+    otp,
     passwords,
     paths,
     registry,
@@ -130,12 +131,15 @@ def _opened(
             detected.append(adapter.name)
         if adapter is None:
             yield _no_adapter(url)
-        elif isinstance(adapter, NeedsAccount) and not (
-            session and adapter.signed_in(page.request, adapter.account_scope(url))
-        ):
-            yield _sign_in_again(page, adapter, user, mine, url, credentials) or (page, adapter)
-        else:
-            yield page, adapter
+            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:
+                yield page, adapter
 
 
 def _sign_in_again(
@@ -536,7 +540,7 @@ def login(
             accounts.wait_for_person(account, scope, data, session),
         )
     else:
-        result = _headless(data, account, scope, credentials, session, details)
+        result = _headless(data, user, account, scope, credentials, session, details)
         command = login_command(adapter, user, url)
         report.status, report.reason = (
             result.status,
@@ -574,7 +578,9 @@ def _create(
         report.status, report.reason = Status.BLOCKED, f"password_source: {e}"
         return report
     credentials = (email, password)
-    result = _headless(data, account, report.scope, credentials, report.path, details, create=True)
+    result = _headless(
+        data, report.user, account, report.scope, credentials, report.path, details, create=True
+    )
     command = login_command(account.name, report.user, url)
     report.status, report.reason = result.status, _email_link(result.reason, email, command)
     report.password = "stored"
@@ -588,6 +594,7 @@ def _create(
 
 def _headless(
     data: Path,
+    user: str,
     account: NeedsAccount,
     scope: str | None,
     credentials: Credentials,
@@ -595,14 +602,14 @@ def _headless(
     details: SignUpDetails | None = None,
     create: bool = False,
 ) -> Result:
-    """Signs in, or creates the account with `create`, through the adapter: `ready` once the
-    session is stored."""
+    """Signs in, or creates the account with `create`, through the adapter, an OTP it meets
+    from the user's `otp-commands` entry: `ready` once the session is stored."""
     assert isinstance(account, SignsIn)
     url = account.login_url(scope)
 
     def run(_: list[str]) -> Result:
         result = Result(Status.READY, url, account.name)
-        with open_page(data, None) as page, _stops(result):
+        with open_page(data, None) as page, _stops(result), otp.source(user, account.name, scope):
             accounts.sign_in(page, account, scope, *credentials, session, details, create)
         return result
 

atsfill-0.0.4.dev136/src/atsfill/core/otp.py

@@ -0,0 +1,109 @@
+"""OTPs a hiring system emails before it goes on (ADR 0015): the user's `otp-commands` entry
+gives each one, and atsfill types it where the adapter found the OTP step's input. The core
+sets the source for the command; an adapter only calls `enter`."""
+
+import shlex
+import subprocess
+import time
+from collections.abc import Generator
+from contextlib import contextmanager
+from contextvars import ContextVar
+from dataclasses import dataclass
+from datetime import UTC, datetime
+
+from atsfill.core import paths
+from atsfill.core.adapter import Blocked
+from atsfill.core.browser import Locator
+
+OTP_TIMEOUT_S = 90  # from the step showing to the OTP typed in: a mail takes seconds
+POLL_S = 3  # between runs of a command that has no OTP yet
+EVERY_ADAPTER = "all"  # the `otp-commands` key for the adapters without their own
+
+
+@dataclass
+class Source:
+    """The user's `otp-commands` entry for the adapter, None without one, and when the last
+    OTP was asked for: an OTP from before is not this one."""
+
+    adapter: str
+    command: str | None
+    scope: str | None
+    since: datetime
+
+
+_source: ContextVar[Source | None] = ContextVar("otp_source", default=None)
+
+
+def command(user: str, adapter: str) -> str | None:
+    """The user's `otp-commands` entry for the adapter, else for every adapter."""
+    entries = paths.config(user).get("otp-commands", {})
+    return entries.get(adapter) or entries.get(EVERY_ADAPTER)
+
+
+@contextmanager
+def source(user: str, adapter: str, scope: str | None) -> Generator[None]:
+    """Makes the user's entry the source of every OTP the adapter meets within, the first not
+    older than now."""
+    token = _source.set(Source(adapter, command(user, adapter), scope, _now()))
+    try:
+        yield
+    finally:
+        _source.reset(token)
+
+
+def enter(inputs: Locator, email: str, step: str) -> None:
+    """Types the OTP emailed to `email` into the step's input, or one character into each of
+    its inputs. Raises `Blocked`: `no_otp_command` without an entry, `otp_not_received` when the
+    command prints none within `OTP_TIMEOUT_S`, `otp_rejected` when what it prints does not fit
+    the inputs; `step` names where the OTP was asked, for the reason."""
+    current = _source.get()
+    asked = f"{step} sent an OTP to {email}"
+    if current is None or current.command is None:
+        adapter = current.adapter if current else "the adapter"
+        raise Blocked(f"no_otp_command: {asked}; no `otp-commands` entry for {adapter}")
+    otp = _wait(current, email, asked)
+    count = inputs.count()
+    if count > 1 and count != len(otp):
+        raise Blocked(
+            f"otp_rejected: {asked}; the OTP command printed {len(otp)} characters"
+            f" for {count} inputs"
+        )
+    if count > 1:
+        for box, character in zip(inputs.all(), otp, strict=True):
+            box.press_sequentially(character)
+    else:
+        inputs.fill("")
+        inputs.press_sequentially(otp)
+    current.since = _now()
+
+
+def _wait(current: Source, email: str, asked: str) -> str:
+    """Runs the command until it prints an OTP, each run within the time left: one that waits
+    for the mail itself runs once."""
+    assert current.command is not None
+    since = current.since.isoformat(timespec="seconds").replace("+00:00", "Z")
+    filled = {"{email}": email, "{scope}": current.scope or "", "{since}": since}
+    args = shlex.split(current.command)
+    for placeholder, value in filled.items():
+        args = [a.replace(placeholder, value) for a in args]
+    deadline = time.monotonic() + OTP_TIMEOUT_S
+    while (left := deadline - time.monotonic()) > 0:
+        try:
+            run = subprocess.run(args, capture_output=True, text=True, timeout=left)
+        except subprocess.TimeoutExpired:
+            break
+        except OSError as e:
+            raise Blocked(
+                f"otp_not_received: {asked}; the OTP command `{args[0]}` failed: {type(e).__name__}"
+            ) from None
+        if run.returncode == 0 and (otp := next(iter(run.stdout.split()), "")):
+            return otp
+        time.sleep(min(POLL_S, max(0.0, deadline - time.monotonic())))
+    raise Blocked(
+        f"otp_not_received: {asked}; the OTP command `{args[0]}` printed none"
+        f" within {OTP_TIMEOUT_S}s"
+    )
+
+
+def _now() -> datetime:
+    return datetime.now(UTC).replace(microsecond=0)

{atsfill-0.0.4.dev134 → atsfill-0.0.4.dev136}/src/atsfill/registry.toml

@@ -327,7 +327,7 @@ dry_run_verified = { date = 2026-10-22, version = "0.0.3", by = "adapter_gate",
 [isolvedhire]
 kind = "ats"
 share = 0.0047
-account = "to_read"  # one account for the whole system, signed in per employer's site; Apply now verifies the email or phone with a one-time code, the sign-in's sign-up sets a password instead
+account = "to_read"  # one account for the whole system, signed in per employer's site; Apply now verifies the email or phone with an OTP and asks the same details as the sign-in's sign-up, which sets a password instead
 hosting = ["hosted"]
 adapter = "isolvedhire"
 mapped = { date = 2026-10-20, version = "0.0.2", by = "agent", commit = "7934b25" }