Compare commits

...

83 Commits

Author SHA1 Message Date
6c2e457225 T14.3 (D26, BL-061): the sync badge shows the true state and gets out of the way
The badge words live in one function, badgeModel(). States: sending, retrying,
held for sign-in, not saved on this device, rejected (with the reason), read and
queue, another person's changes, and all sent. Every state names the project.
Sign in is a real link to login.html?next=. Dismiss is a real button and removes
only the changes the project refused. Both are 44px or more with a focus ring.

BL-061: the console pages (Admin, User Directory) never show the badge. All sent
shows only after real work. The badge picks a free spot on the screen. One very
dense screen case is left and logged as BL-072.

tests/sync_badge_check.py (87 checks). autosave_check reads the new badge words.
2026-10-17 15:12:25 -07:00
b78b9b3707 docs: remove stray merge markers from backlog.md
Three conflict marker lines (ours, divider, theirs) were committed in an earlier
merge. Both sides are separate items (BL-069 and BL-062 to BL-068), so only the
marker lines are removed. No item text changed.
2026-10-17 14:47:54 -07:00
40827d5371 T14.2 (D27): the offline sign-in window follows the server
/api/auth/me returns session_expires_at (the session token exp, UTC). The browser
keeps it and never extends it: the fixed 12 hours and the sliding reset are gone.
Offline before that time the app opens as normal. Offline after it the app opens in
read-and-queue mode: no redirect, one mode line, changes are queued and held until
a page load gets a good answer from the server. wpCacheAuth refreshes the cached
user without moving the end time.

D26 and D27 recorded as Accepted. tests/session_expiry_check.py (22 checks) fails
against the old 12 hour rule.
2026-10-17 14:18:53 -07:00
73f0b5e69d T14.1 (D26): a sign-in problem never destroys a queued change
A 401 holds the queue: nothing is marked dead, no try is counted, and only
wp-auth-ready releases it. A 403 marks only that change dead, with a reason.
qWrite reports failure; a change the device cannot store stays in memory and the
badge says so. Each change has an owner and is sent only under that person.

tests/outbox_check.py (26 checks) fails against the old 401 rule.
2026-10-17 14:00:52 -07:00
512f0b6b1d Wave 14: do not widen B5; badge states belong to D26 and BL-061 2026-10-17 13:27:37 -07:00
ae649b5ed7 Wave 14 spec (D26, D27, B5, BL-061) and the T13.1 gate; decisions 2026-10-17 2026-10-17 13:27:28 -07:00
4fc6e8a01b T13.11: session limit defaults to 8 hours (D25) 2026-10-17 13:25:58 -07:00
2c199f6f3f T13.6: confirm the auto-disable audit row in the Admin Console (D18) 2026-10-17 13:15:09 -07:00
c3519d3e53 T13.6: record the live Okta sync run and the final verification (D18) 2026-10-17 12:39:02 -07:00
1a3468effd T13.10: DPoP for the Okta Management API calls, auto-detected (D24) 2026-10-16 17:10:19 -07:00
83e77ec622 T13.9 follow-up 3: read pretty-printed and hand-copied JWKs, report the line and column of a syntax error (D23) 2026-10-16 16:56:11 -07:00
c75450a000 T13.9 follow-up 2 fix: keep quote marks that belong to brace-less JWK fields (D23) 2026-10-16 16:24:21 -07:00
5f8ebab5b2 T13.9 follow-up 2: name PEM keys, forgive missing braces and double encoding, give a length hint (D23) 2026-10-16 16:24:05 -07:00
5cf6355a01 T13.9 follow-up: forgive paste damage in OKTA_SYNC_PRIVATE_KEY and name the failing step (D23) 2026-10-16 16:04:52 -07:00
d137d690f9 T13.9: sign in to the Okta Management API as an OAuth service app, private_key_jwt (D23) 2026-10-16 15:29:32 -07:00
ad1b8273c0 T13.8: run the stack in Docker on a PC, local compose override and steps (D22); log BL-070 2026-10-16 15:08:01 -07:00
bcef0e8145 T13.7: dry run for the Okta sync, OKTA_SYNC_DRY_RUN (D22) 2026-10-16 14:53:05 -07:00
2d4e96d668 T13.6: record full-suite result on the release tree (D18) 2026-10-16 14:17:39 -07:00
493ead725d Release: wave 11 + T13.2-T13.5 (D18 Okta sync), T13.1 held back until T14.1; mobile roadmap docs (BL-062..BL-069) 2026-10-16 14:03:33 -07:00
2abd55c745 T13.4 follow-up: make the sync's log lines visible under gunicorn (D18)
Nothing configures Python logging and gunicorn only configures its own loggers,
so INFO lines from wpsuite.* were dropped: with the production launch command a
healthy start printed no Okta lines, and an operator could not tell the sync was
off from on-and-quiet. okta_sync's logger now has its own stderr handler, only
when the root logger has none. Verified with real gunicorn, 2 workers, with and
without a token. Other modules' output is unchanged.
2026-10-16 13:30:47 -07:00
bbfa403117 D18 docs: admin instructions for accounts the Okta sync disabled (T13.6)
New DEPLOYMENT.md section: how to see what the sync did, how to re-enable a
person (fix Okta first, then Enable in the User Directory), who may do it
(admin; super user only for exclusive-scope accounts), the host CLI when no
admin can sign in, and how to turn the sync off if it disabled the wrong people.
2026-10-16 12:05:03 -07:00
253886923c T13.6 (part): test T13.1's sliding session, and record what it found
T13.1 shipped with its done-when list unchecked and no test of its own. Adds
tests/session_idle_check.py (28 checks): continuous activity survives 30 minutes
but not the ceiling, an idle session gets 401, the cookie is not rewritten per
request, a pre-D18 token still gets a ceiling via iat, identity carries forward,
both variables are documented. Mutation-tested (no throttle, no ceiling, a fresh
ceiling for legacy tokens each fail it).

Notes in wave-13.md: /api/auth/* is exempt from the refresh, and the wave exit
criteria say AUTH_SESSION_HOURS 2 while T13.1 and the code say 8.
2026-10-16 11:41:29 -07:00
763ab8d98d T13.5: verify an auto-disable reads clearly in the admin console (D18)
No UI change. The existing Activity log card already renders a sync disable
legibly: system:okta_sync / user deprovisioned by sync / user / <name> /
okta_status: SUSPENDED|MISSING. tests/okta_sync_ui_check.py runs the real sync
on a throwaway database and reads the real page at 1440px and 390px (28/28):
rows, search, filter, no sideways scroll, no JS errors, and the disabled
account refused on its next request. Does not depend on CR-019's usage card.
2026-10-16 11:36:38 -07:00
f30989d4b8 T13.4: run the Okta sync on a schedule (D18)
A daemon timer thread starts from a new lifespan hook in app.py and calls the
T13.3 sync every OKTA_SYNC_INTERVAL_SECONDS (default 900, minimum 300). With no
OKTA_API_TOKEN it starts nothing and the startup log says so.

The api runs 2 gunicorn workers, so each starts its own timer. A single atomic
conditional UPDATE on one app_settings row (key okta_sync) is the gate: exactly
one worker wins each cycle, on SQLite and Postgres, with no lock held. The row
survives a restart, so a restart inside the interval starts no second run. A
fetch is now capped at 120 s in total, so a run is always shorter than the
minimum interval and cannot overlap the next. No migration needed.

docker-compose.yml passes OKTA_API_TOKEN, OKTA_ORG_URL,
OKTA_SYNC_PROFILE_ATTRIBUTE and OKTA_SYNC_INTERVAL_SECONDS to the api service.

tests/okta_sync_schedule_check.py: 38 checks including an 8-worker race on a
file database (exactly one winner, 16 rounds) and fail-closed through the
scheduled path. okta_auth_check.py still 22/22.
2026-10-16 11:34:13 -07:00
103e4d40ee T13.3: Okta deprovisioning sync job, fail closed (D18)
run_sync() compares the Okta user list (T13.2) to active local accounts and
disables the ones Okta no longer vouches for. One AuditLog row per change,
actor system:okta_sync, action user_deprovisioned_by_sync.

Fail closed: any exception from the fetch, an empty or untrusted answer, or a
failed save changes nothing and writes nothing. The fetch runs before the
database is read, so a failed fetch has no path to a change. It only ever
disables; an already-disabled account is untouched and gets no new row.

Decided with Matt 2026-10-16: disable on missing, SUSPENDED or DEPROVISIONED.
PASSWORD_EXPIRED, LOCKED_OUT and RECOVERY do not disable (the job never
re-enables, so a literal "not ACTIVE" would lock people out for good).
Added a guard: no match between any active local account and any Okta user is
refused as a wrong identity attribute, not read as a mass offboarding.

tests/okta_sync_job_check.py: 71 checks; removing the fail-closed branch and the
guard fails 28 of them. BL-069 logs the missing per-run cap.
2026-10-16 11:31:39 -07:00
2f7de6e33b T13.2: Okta Management API client (D18)
New server/okta_sync.py: lists every Okta user and status with its own
read-only credential (OKTA_API_TOKEN, SSWS), separate from the OIDC client.
Follows pagination. Every failure raises OktaSyncError; an error is never an
empty list, because T13.3 reads an empty list as "nobody is active".

Also refuses: a next-page link to another host (token never leaves the org),
a redirect, a chain over 50 pages (a cut-off list looks like missing users),
a bad item among good ones (never skipped), and an empty list.

tests/okta_sync_check.py: 52 checks, self-contained (httpx MockTransport).
Not wired into app.py yet. T13.3 uses it; T13.4 starts it on a schedule.
2026-10-16 11:28:57 -07:00
d42ae0c65b Merge pull request 'feat/wave-12-bulk-users' (#4) from feat/wave-12-bulk-users into main
Reviewed-on: #4
2026-10-06 22:41:38 +00:00
9fc2d307bb Merge pull request 'feat/wave-16-on-main' (#3) from feat/wave-16-on-main into main
Reviewed-on: #3
2026-10-06 22:40:22 +00:00
e50a05a1e0 T12.6: wave 12 closed - browser_check passes after the re-point
Matt reran tests/browser_check.py on the re-pointed probe: all
passed. Every T12 done-when and every wave 12 exit criterion is now
checked in wave-12.md.
2026-10-06 14:05:43 -07:00
b2b3774dea T16.4: security_check skips the D18 refresh check where D18 is absent
Wave 16 rebuilt on main (feat/wave-16-on-main, 2026-10-06) so it can
ship without wave 11 and T13.1. main has no sliding refresh, so the one
D18 check now runs only when auth.maybe_refresh_token exists; on main
it instead proves a valid token near its expiry is still accepted.
security_check 36/36 on this branch; smoke 27/27.
2026-10-06 13:28:22 -07:00
cfecdca3f7 T16.4: record the production check for D20 (no duplicate complete SOPs)
(cherry picked from commit 2420c73de4)
2026-10-06 13:27:50 -07:00
be3157baf2 T16.4: browser probes pass; cdp.py starts from an elevated shell
files_check.py 36/36 (T16.2), sample_check.py 10/10 and
critical_reopen_check.py 11/11 (T16.3), run on Matt's machine with
Edge 154. T16.2 and T16.3 done; wave 16 verification complete.

tests/cdp.py: every probe first failed 'exited rc=0 without binding
the port'. The shell was elevated; Edge and Chrome de-elevate by
relaunching through Explorer and the relaunch drops the debugging
port ('Edge is running elevated: 1' in the browser log). Adds
--do-not-de-elevate on Windows and a 15 s grace for the port after an
rc=0 exit. Both inert on a normal shell and off Windows.

(cherry picked from commit f752ae3677)
2026-10-06 13:27:50 -07:00
0157b4b325 T16.4: wave 16 verification record
security_check.py 36/36 (da1325c: 20/36, the 16 failures are the
findings). sec_probe.py: only S3 and S12 change. equivalence_check
IDENTICAL vs da1325c (canonical SOP id in the scenario). Smoke test
27/27. pip-audit clean.

Open: files_check.py (T16.2), sample_check.py and
critical_reopen_check.py (T16.3) need a machine with Edge; those two
tasks stay not-done until they pass.

(cherry picked from commit f0750212ca)
2026-10-06 13:27:49 -07:00
c0b736e503 T16.3: D20 one SOP per project
- A SOP posted with no id lands on sop__<project_id>, the id pushSOP
  has always used. Creating (or moving in) a SOP under any other id on
  a project is refused with 400.
- While a project has a complete SOP, writing another complete one
  needs Project Admin (the existing rule only checked the posted row).
- New project_baseline_sop(): canonical row when complete, else the
  latest complete (pre-D20 rows). Used by /api/sops/latest with
  complete=true&project_id, project_summary, project_sop_team and
  project_qa_group, so a rogue row made before the fix cannot stay
  the baseline or the mail routing.
- Existing rows under other ids stay and keep their old rules.

Security review SEC-02 (a project_user took over the baseline and the
PM/CM/QA mail routing with one POST).

security_check.py: 36/36 with D19-D21. Against da1325c: 7 D20 checks
fail (the findings). Smoke test 27/27; seed_demo writes the canonical
id.

(cherry picked from commit 7bd5ab104d)
2026-10-06 13:27:48 -07:00
f4d74879cc T16.2: D19 uploaded files download safely
New server/files_http.py; get_wp_file uses it.
- PDF and raster images (png, jpeg, gif, webp, bmp, avif) open inline,
  as before; Cache-Control unchanged for the offline drawing cache.
- Every other type, SVG included, downloads as an attachment with
  Content-Security-Policy: sandbox; default-src 'none'.
- SVG uploads stay accepted (decided 2026-10-02: accept, download only).
- Content-Disposition: ASCII fallback + RFC 5987 filename*, control
  characters and quotes replaced. nosniff from the API too.

Security review SEC-01 (stored XSS through an SVG drawing) and SEC-15e
(non-Latin-1 names gave 500; CR/LF reached the header).

security_check.py D19: 20/20 total with D21. Against da1325c: 6 fails
(the findings); every inline/cache/access check passes on both.

(cherry picked from commit 14ecb75c88)
2026-10-06 13:27:48 -07:00
d962ab2381 T16.1: D21 session decode fails closed; PyJWT 2.15.1
decode_token treats any decode failure, and any cookie over 4096 chars,
as not signed in, and requires exp and sub. PyJWT 2.13.0 -> 2.15.1
(pip-audit: 13 advisories -> none).

Security review SEC-07: a crafted 1.6 KB cookie with no account gave
500 + stack trace; now 401.

New tests/security_check.py (no browser): D21 section 6/6. Against
da1325c with PyJWT 2.13.0 it fails 3 checks (crafted cookie 500,
token with no exp accepted, old pin) - the findings. The over-long
cookie and the two still-works checks pass on both.
Smoke test 27/27.

(cherry picked from commit 01ce7e941c)
2026-10-06 13:27:47 -07:00
8dd0afaba4 wave 16: planning docs for D19, D20, D21
D19 - uploaded files download safely (SEC-01, SEC-15e)
D20 - one SOP per project (SEC-02)
D21 - session decode fails closed, PyJWT 2.15.1 (SEC-07)

From the security review of 2026-10-01. Decision record and task
breakdown only in this commit - no code yet.

(cherry picked from commit 1c221a122e)
2026-10-06 13:27:46 -07:00
912cf75027 T12.6: browser results, screenshots, browser_check re-pointed
Matt's run (Edge/Chrome, one at a time): bulk_users_ui_check 19/19,
console_dialogs_check 16/16, mobile_check 24/24, a11y_check 22/22.

browser_check 67/71: its four failures asserted column POSITIONS
(9 columns; r.cells[3]/[4] for Permissions/Project role). CR-020's
selection column comes first, so those read Username and Email. The
probe now expects 10 columns with the selection column first, finds
the cells by header name, and checks your own row has no selection
box. Verified on the real page in the DOM harness; rerun to close.

After-screenshots committed in docs/reference/baseline/wave-12/.
BL-061 logged: the pre-existing sync badge covers a control for ~2 s
after load (pointer-events:none, so never blocks a click); belongs
with wave 14's badge work.
2026-10-06 11:18:39 -07:00
d04a0ff414 T12.6: wave 12 verification record, browser probe, BL-060
- tests/bulk_users_ui_check.py (new): selection, keyboard Space on a
  row box, toolbar role change, super-user CSV with good and bad lines,
  add-to-project with a role, typed DELETE, all end to end against a
  real server; 390px bar layout; writes after-screenshots to
  docs/reference/baseline/wave-12/. Needs a browser: to be run on
  Matt's machine.
- tests/cdp.py: --do-not-de-elevate and the rc=0 grace, the same
  change as wave 16 T16.4 (identical content, merges cleanly), so the
  probes start from an elevated shell on this branch too.
- Verification record in wave-12.md: bulk_users_check 61/61 (main
  7/18), single-user routes identical before/after on 16 calls, DOM
  harness 48/48, jsdom against a real server 13/13, smoke 27/27,
  seed_demo OK. Server-checkable done-when boxes ticked; the browser,
  screenshot and full-suite boxes stay open until run on Edge.
- BL-060 logged: a super user's refusal reason promises a project
  access change neither the dialog nor the bulk route allows. Needs
  Nick; not fixed here (scope).
- file-map.md: wave 12's two new checks.
2026-10-06 11:08:03 -07:00
1c4d1bbccb T12.5: CR-020 bulk delete with typed confirmation
'Delete selected…' in the bulk bar. The dialog lists every affected
username (scrolling inside the dialog for a long list), says the
delete cannot be undone and offers disable instead, and sends nothing
until the word DELETE is typed in capitals, whatever the count
(confirmed 2026-10-06). Wrong words keep the dialog open with the
reason; cancel sends nothing.

Your own account cannot be selected; if it ever reached the request,
the server refuses that row and the report names it with the reason.

The bulk delete is a prompt-style dialog, so it is covered in
tests/console_dialogs_check.py (its docstring asks for exactly this):
new section 4 drives it in the browser with native dialogs poisoned.
DOM harness: 48/48.
2026-10-06 11:05:01 -07:00
74d3bc4af7 T12.4: CR-020 CSV upload (usernames only)
POST /api/auth/bulk-users/resolve reads a list of usernames (first
column; comma, semicolon or tab; header skipped) and answers line by
line, the CR-005 validate-and-report pattern. A line is rejected, with
its number and reason, when it names nobody the caller can see ('User
not found', as everywhere else), an account they may not change (the
single route's own reason), their own account, or a username already
listed (duplicate of line N). An email address resolves only when
exactly one account has it. Nothing is changed by this route.

The console's 'Select from CSV' turns the accepted accounts into the
ordinary selection (filter reset so every selected row is visible) and
lists every rejected line. The action, confirm and per-row report are
the checkbox ones, through the same T12.1 routes, which re-check each
row: a CSV cannot reach an account a checkbox could not.
Usernames only, action in the toolbar (decided 2026-10-06). Files over
1 MB are refused before upload; FileReader fallback for browsers
without Blob.text().

bulk_users_check.py: 61/61. DOM harness: 40/40.
2026-10-06 11:04:01 -07:00
681048197a T12.3: CR-020 bulk-action toolbar
Role change, enable/disable, and project add/remove on the selected
rows, wired to the T12.1 endpoints. Delete is T12.5.

- The toolbar offers only what the caller may do: grantable roles,
  managed projects (archived last, marked), grantable per-project roles.
- Every action confirms through wpConfirmDialog naming the exact count
  (and for projects, the project and role) before anything is sent.
- The result lists every failed row with the server's reason, plus the
  changed / already-set counts; a partial failure is a warning, an
  all-failed batch an alert, a server error says nothing was changed.
  Never a blanket success. Announced through the live-region banner.
- The directory reloads afterwards, which clears the selection.

DOM harness (jsdom, real page and scripts, mocked API): 30/30 with
T12.2.
2026-10-06 11:02:09 -07:00
cf46b3ce42 T12.2: CR-020 row selection in the User Directory
- A checkbox per row the caller may change; select-all covers only the
  rows the current filter and search show, and is indeterminate on a
  partial selection.
- Your own row and rows you cannot change show a disabled box whose
  label gives the reason.
- Changing the filter or the search clears the selection and says so
  in a live region (decided 2026-10-06), so no hidden row stays
  selected.
- The bulk bar appears at one or more selected rows and is hidden (out
  of the tab order) at zero. Actions arrive in T12.3.
- Selection is updated in place, not by re-rendering, so focus stays on
  the checkbox just used. One delegated listener; no ids in inline
  handlers.
- The email-width rule now targets td.ell, not nth-child(3), which the
  new column would have shifted.

Checked in a DOM harness (jsdom) against the real page and scripts:
14/14; against main the selection checks fail. Browser probe at
390px/1440px follows in T12.6.
2026-10-06 11:01:02 -07:00
0e79e17a57 T12.1: CR-020 bulk user endpoints
POST /api/auth/bulk-users/{active,role,projects,delete} take a list of
user ids (max 500) and run each row through the same guards and audit
as the single-user route: the rules now live once, in guard_target and
apply_user_{active,role,delete,projects}, which the single-user routes
call too.

- A refused row is reported with its reason; the rest still run; the
  response counts ok / unchanged / failed. Never a blanket success.
- The caller's own account is refused only on its own row.
- One AuditLog row per changed account, same action and shape as the
  single route. A row already in the requested state is 'unchanged'
  and writes no audit row.
- Project assignment is add/remove to ONE project with a per-project
  role (confirmed 2026-10-06); roles on the user's other projects are
  carried over as stored.
- Routes sit under /api/auth/bulk-users/ because /api/auth/users/bulk/
  would match {user_id}='bulk'.

New tests/bulk_users_check.py (no browser): 47/47. Against main: the
7 single-route checks pass, every bulk check fails.
Single-user routes compared before/after on 16 calls (200/400/403/404):
identical responses, audit rows and memberships. Smoke test 27/27.
2026-10-06 10:57:48 -07:00
286e629782 wave 12: plan for CR-020 on a branch from main; details confirmed
Brings docs/waves/wave-12.md and decisions-2026-09-17.md across from
feat/waves-11-13 (planning docs only, no wave 11 or 13 code), so the
PR into main is wave 12 alone.

Confirmed 2026-10-06 by Matt Mabrey: typed DELETE for bulk delete;
project assignment is add/remove per project; changing the filter
clears the selection; the CSV holds usernames only.
2026-10-06 10:53:29 -07:00
da1325c8a1 T11.7: full verification pass - wave 11 closed out 2026-09-24 16:40:03 -07:00
4f3a94bd06 T11.6 follow-up: fix autosave_check.py regression from the retired tracker
Found running the full tests/*_check.py suite as part of a deployability
check on feat/waves-11-13: autosave_check.py's "section 7" asserted that
calling trackStepDwell() still wrote an event into wp-usage.js's
localStorage log (wp_suite_analytics_v1). That assertion predates CR-019
and was checking that the autosave guard hadn't accidentally clobbered
the pre-existing analytics dwell listener - a real concern at the time.

T11.6 (previous commit b2a083a) retired that listener on purpose: track()
is now a documented no-op and wp-usage.js is gone, so the localStorage key
is never written to any more. The test was still asserting the old
behavior, so it now correctly failed (0 -> 0) - this was a gap in T11.6's
own verification (only tests/baseline_shots.py was run for it at the
time; the full suite wasn't).

Fix: rewrote section 7 to check what's actually still true - autosave's
own registration (WPAutosave / sopDraftId), and that the retired
trackStepDwell() is a harmless no-op (exists, doesn't throw) rather than
missing or broken - instead of asserting it still records anywhere.

Verified: tests/autosave_check.py now passes 33/33 (was 33/34, exit 1).
Also ran the complete tests/*_check.py suite (39 scripts) as a
deployability check for the whole feat/waves-11-13 branch:
  - 38/39 exit 0 after this fix
  - token_check.py exits 2 when run with no arguments by design (it needs
    --out or --compare) - a harness-invocation detail, not a test failure;
    already confirmed non-regression in wave 10
  - generalinfo_check.py has one known pre-existing failure (a raw colour
    literal check against html/wp-creation-styles.css, a file untouched by
    any wave 11/13 work) - already diagnosed as pre-existing in wave 10,
    unrelated to CR-019/D18
Also re-verified the usage_events migration (T11.1) round-trips cleanly
on SQLite (upgrade/downgrade/upgrade) and renders clean, valid DDL for
Postgres via `alembic upgrade ... --sql` (TIMESTAMP WITH TIME ZONE / JSON,
no SQLite-only syntax) - no BL-027-class defect.
Backend smoke test (27/27) and seed_demo.py still pass.
2026-09-24 16:38:55 -07:00
2842ec996c Add session notes for 2026-09-23 (CR-019 / D18 work) 2026-09-23 15:06:02 -07:00
b2a083ac7c T11.6: retire the per-browser Usage report (CR-019)
Removes the old "Usage logs" card from admin.html/admin.js (the
usage-admin panel + loadUsage(), D5/T7.10) now that T11.5's real,
server-side Activity & usage card exists and reads real per-user data
instead of per-browser localStorage.

wp-usage.js is deleted outright, along with its three <script> includes
(admin.html, wp-creation-index.html, work-package-suite.html) - it had
no reader left once the panel above it was removed (the "download the
full event log" button lived only in that panel), and per the original
CR-019 decision record it was never reliably tied to a real identity,
so it was never a candidate data source for the new report either.

Its two call sites (wp-creation-app.js, work-package-suite-app.js) keep
a local track() function as a documented no-op rather than having each
of their ~45 individual track('event', ...) call sites deleted one at a
time - that would be a much larger, riskier diff for the same outcome
(no data is recorded either way), and each call site still marks what
was worth recording if usage analytics are ever rebuilt server-side.
work-package-suite-app.js's dwell-timer plumbing (_stepEnter /
trackStepDwell), which only ever fed track(), was left in place for the
same reason: inert, not broken.

Also removes tests/usage_check.py, which tested exactly the retired
feature, and updates its line in docs/reference/file-map.md to point at
the 2026-09-17 decision record instead.

Verified:
  - grep across the whole repo for WPUsage / wp-usage.js / usage-admin /
    usage_check: no live references remain, only explanatory comments
    and planning docs (decisions-2026-09-17.md, wave-11.md) that
    describe the removal itself
  - node --check on all three touched .js files: no syntax errors
  - full backend smoke test (27/27) and seed_demo.py still pass
  - tests/baseline_shots.py --pages admin,creator,sop at 390px/1440px,
    run locally: all three pages render with no new JS errors (the one
    "beforeunload" log line on sop/creator at 1440px is pre-existing
    harness noise from wp-autosave.js's unsaved-work guard, unrelated
    to this change) and no horizontal overflow; refreshed baseline
    screenshots committed alongside this change
2026-09-23 14:46:32 -07:00
0b5ab59518 T11.5: verify Activity & usage card at 390px/1440px 2026-09-23 14:40:30 -07:00
a6c3fbfe50 T11.5: admin console Activity & usage card (CR-019)
New card in admin.html/admin.js, above the old per-browser Usage logs
card (which T11.6 retires next). Filters (date range, project, user,
tool) drive GET /api/usage/summary; two export buttons call
GET /api/usage/export (raw / sanitized) and save the CSV via a Blob,
same download pattern wp-usage.js already uses.

Access: the card lives inside admin.html, already gated admin-only
client-side by gateByRole() (unchanged) - a non-admin never sees the
card. The underlying API is gated server-side by require_user_manager
regardless (admin or project_super_user on >=1 project), independent
of and stricter than the client-side gate, so a non-admin request is
refused even if someone reached the endpoint directly.

Accessibility (C1): every control is a real <input>/<select>/<button>,
keyboard-operable. Status/export banners use the existing '.banner' /
'*-banner' id convention, which console-util.js's MutationObserver
already turns into aria-live (role=status, or role=alert on a '.bad'
banner) - no new announcement plumbing needed. No new CSS: reuses
.toolbar/.banner/.card/.row/.kv/.users, so nothing here adds a second
token source (the token rule).

Verified so far:
  - node --check html/admin.js: no syntax errors
  - every id admin.js's new code references exists in admin.html
    (scripted diff against the full getElementById/id= sets)
  - live-server check: GET /api/usage/summary with the exact
    (possibly-empty) query string _activityFilters() builds returns
    the {active_users, per_user_last_active, by_tool, event_count}
    shape renderActivity() expects; project_id filter narrows
    correctly; GET /api/usage/export?sanitize=true returns
    text/csv with the expected header row
  - full smoke test + seed_demo.py still pass

NOT yet verified: rendering at 390px/1440px with before/after
screenshots (CLAUDE.md verification step). This sandbox has no
headless-capable browser (no chromium/msedge on PATH) and the
playwright/chromium download is blocked by this environment's
network allowlist, so tests/cdp.py's harness can't run here. Deferred
to T11.7, same as wave 10's browser checks — flagging rather than
skipping silently.
2026-09-23 12:31:55 -07:00
2de76d52e6 T11.4: usage export endpoint (raw + sanitized CSV)
CR-019 / wave 11. Adds GET /api/usage/export, reusing _usage_query()'s
scoped filters (from/to/project_id/username/tool) and the same
require_user_manager gate as /api/usage/summary. Two modes:

- raw (default): real usernames, for internal admin use.
- sanitize=true: usernames replaced with an HMAC-SHA256 pseudonym
  (keyed with auth.SECRET_KEY, 16 hex chars, 'u_' prefix) so the file
  can be fed into PowerBI or another external reporting tool without
  carrying real identities. HMAC chosen over a plain hash since the
  username space is small enough to brute-force a bare digest.

Both modes emit at, username, project_id, tool, event as columns and
deliberately omit the detail JSON column in both modes to avoid an
identity leak riding along inside free-form detail data. Response is
returned with a Content-Disposition: attachment header and a filename
that encodes mode + date.

Verified locally against a throwaway SQLite DB with two seeded users
and four seeded UsageEvent rows:
  - raw export contains the real usernames and matches the summary
    endpoint's event_count for the same session state
  - sanitized export contains no real username or email anywhere in
    the file body, across two independently-issued export calls
  - the same real user maps to the same pseudonym both within one
    export and across the two separate export calls
  - raw and sanitized rows line up 1:1 on at/tool/event for the same
    filter set
  - the tool= filter narrows the export the same way it narrows the
    summary
  - a plain project_user is refused with 403; an unauthenticated
    request is refused with 401
  - full smoke test (27/27) and seed_demo.py both still pass
2026-09-23 12:25:05 -07:00
8e863ae7d0 T11.3: usage aggregation endpoint with filters (CR-019)
GET /api/usage/summary: active-user counts by day/week/month, per-user
last-active, per-tool breakdown. Filters (from/to/project_id/username/
tool) combine. Gated by require_user_manager - same boundary as the User
Directory. A project_super_user is scoped to events tied to projects
they manage plus their own activity (managed_project_ids), never another
user's suite-wide activity outside that; an app admin sees everything.

_usage_query() factored out so T11.4's export can never disagree with
what this endpoint counted - same filtered row set, not two derivations.

Verified: admin sees all seeded events; a project_super_user scoped to
one of two projects correctly sees only that project's events plus their
own account-wide activity, and specifically does NOT see the admin's
other-project or no-project activity; date/tool/project filters each
narrow results correctly and combine.
2026-09-23 12:19:14 -07:00
6cde6e3f60 T13.1: idle timeout + absolute ceiling (D18)
Sessions now slide on activity (AUTH_IDLE_MINUTES, default 30) capped by
a hard ceiling from original sign-in (AUTH_SESSION_HOURS, meaning changed,
default 12 -> proposed 8). login_at carried across reissues so the ceiling
survives refreshes; pre-D18 tokens with no login_at fall back to iat.
Refresh is throttled (~IDLE_MINUTES/3) so the cookie isn't rewritten on
every request. Wired into auth_gate (server/app.py) - no DB hit, reads
only the already-validated claims.

Verified: 7 unit-level checks (fresh-token expiry, past-ceiling refusal,
throttling, mid-session extension, legacy-token fallback both live and
expired, idle cutoff itself) all pass, plus the full 27-check smoke
suite still passes end to end through the new middleware path.
2026-09-23 11:40:59 -07:00
358469531c D18: revise T13.1 to idle timeout + absolute ceiling
Matt asked whether idle time would be a better fit than a flat session
length. It is, but idle-alone weakens D18's own purpose - a continuously
active session would never force a fresh Okta recheck on its own. Decided:
both. AUTH_IDLE_MINUTES (new, default 30) slides the session on activity;
AUTH_SESSION_HOURS (existing var, meaning changes to an absolute ceiling,
default 12 -> proposed 8) caps it regardless of activity.

Docs only in this commit - implementation is T13.1, next.
2026-09-23 11:38:37 -07:00
850b78972b T11.2: capture usage events (CR-019)
POST /api/usage/ping writes one page_open UsageEvent per authenticated
page load, identity from the session (get_current_user), never from the
client. Wired from exactly one place - auth-guard.js's proceed(), after
wp-auth-ready - so this can't drift into six separate per-page copies.

okta_callback now also writes one login event per sign-in.

Verified locally: unauthenticated ping -> 401; a real fake-Okta sign-in
writes exactly one login row and one page_open row, no duplicates.
2026-09-23 11:24:49 -07:00
0652fa732d T11.1: UsageEvent model + migration (CR-019)
New usage_events table, separate from audit_log - see the model docstring
for why. Verified: applies and downgrades cleanly on SQLite, and the
postgresql-dialect --sql render has no risky defaults (the BL-027 class
of defect). No app wiring yet - that's T11.2.
2026-09-23 11:23:14 -07:00
75ac930d0c waves 11-13: planning docs for CR-019, CR-020, D18
CR-019 - usage/activity metrics (admin console), wave 11
CR-020 - bulk editing of users, wave 12
D18    - Okta/AD deprovisioning detection and auto-disable, wave 13

Raised by Matt Mabrey 2026-09-17. Decision record and task breakdowns
only in this commit - no feature code yet.
2026-09-18 09:21:29 -07:00
df20b8f18d wave-10: close out claim mapping and redirect URI, live in production
Confirmed by an actual live Okta sign-in after main (cc64c88) deployed: preferred_username is the right identity claim, and the redirect URI works. Matt matched his existing pre-Okta admin account rather than getting JIT-provisioned as a duplicate. Two deploy-time snags recorded, both Case B (config, not data): OKTA_CLIENT_ID/SECRET/ISSUER left empty in Portainer at first (caught cleanly by is_configured()), then OKTA_ISSUER missing its https:// scheme (surfaced as httpx.UnsupportedProtocol, not a deliberate app error - BL-028 still stands). Neither needed the backup. BTG pilot group now includes Cody and Cameron, awaiting Adrian.
2026-09-09 13:34:32 -07:00
cc64c88c3e T10.10: audit manage_users.py promote
cmd_promote() changed a user's role with no audit trail, unlike the
identical change from the web Admin Console (set_user_role() ->
log_event(), action "role_changed"). Not a new privilege - anyone
with container-exec access already has DB access directly, D16's own
trust-tier reasoning - but there was no record of who ran it or what
changed.

Now writes an AuditLog row matching set_user_role()'s shape, tagged
via:cli (mirrors JIT provisioning's via:okta_jit) since a container
shell exec carries no signed-in identity to attribute the change to.

Verified against a scratch SQLite db: audit row lands correctly, role
change persists, the no-such-user refusal still exits 1 clean.
2026-09-03 16:27:13 -07:00
dc13f9b0e3 T10.8: verification (390px/1440px, full suite, per-task done-when)
Walked T10.1-T10.5's claims against the actual code (env vars, routes,
JIT provisioning, the password-removal sweep, login.html) rather than
re-trusting this file's own prose. No drift found.

Full suite via the Docker runner: 39/41 files clean. token_check.py's
exit 2 is a harness mismatch (needs --out/--compare, not a bare run),
not a failure. generalinfo_check.py is 48/49 - the one failure is a
pre-existing rgba() shadow literal from the D11 Micron-assets merge,
confirmed via git show HEAD to predate this wave; logged as BL-031,
not fixed here. okta_auth_check.py re-run fresh: 22/22.

390px/1440px: baseline_shots.py captured all fourteen shots. Visually
confirmed login.html and users.html show the Okta-only sign-in and the
password-free admin UI at both widths.

Wave 10 complete.
2026-09-03 15:22:03 -07:00
d6eae0d846 T10.9: rollback-aware deploy runbook for the Okta cutover
New DEPLOY-runbook-2026-09-03.md, separate from the 2026-08-04 runbook.
Names the five new OKTA_* env vars, treats the pre-deploy backup as the
only way back once 1d60a608bb51 (drop_local_password) commits since its
downgrade() restores the column but not the data, and splits Rollback
into the fixable case (Okta app integration misconfigured, fix and
redeploy api, no data at risk) versus the severe case (abandoning Okta
for local-password code, which only a destructive backup restore can
reach). States D16's no-break-glass posture plainly.

D17 records the decision and why: staged-deploy-sequence docs and
backlog-only were both considered and declined in favor of the runbook.

Logged to backlog.md rather than fixed here: okta_auth.describe() has
no caller (BL-028), users.failed_attempts/locked_until are vestigial
(BL-029), DEPLOY-login-portal.md is fully stale (BL-030).
2026-09-03 14:25:18 -07:00
d7d1e93dd8 T10.6 - record what was built in wave-10.md 2026-09-03 13:48:08 -07:00
f023192b74 T10.6 - deployment docs and env var reference describe Okta, not the never-shipped LDAP config
D13 never shipped, so DEPLOYMENT.md, server/.env.example and server/README.md
still described the original local-password system as of this task starting -
POST /api/auth/login, bcrypt password_hash, create-admin with a prompted
password, self-service reset-password email flow, AUTH_RESET_MINUTES /
AUTH_RESET_COOLDOWN_SECONDS. All of that is gone as of T10.4; these three files
now describe what actually runs.

server/.env.example and DEPLOYMENT.md's env block both gain the five OKTA_*
variables (ISSUER, CLIENT_ID, CLIENT_SECRET, REDIRECT_URI, IDENTITY_CLAIM),
explained the same way AUTH_SECRET_KEY already was - what it does, where to
get it, what happens if it's missing.

Also updated, not originally named in T10.6's bullet but required for the
documented vars to actually reach a running container: docker-compose.yml's
api service sets environment: as an explicit allowlist, not env_file, so the
four new OKTA_* entries had to be added there too or .env would document
something that silently does nothing. OKTA_IDENTITY_CLAIM specifically is NOT
${OKTA_IDENTITY_CLAIM:-} - compose setting an env var to an empty string is
not the same as leaving it unset, and server/okta_auth.py's own default
(preferred_username) only kicks in when the var is truly unset. Mirrored the
same default in the compose file instead, or every deployment that leaves the
optional line commented out in .env would 503 on every sign-in looking for a
claim literally named "".

server/README.md: replaced the login-portal section with the Okta flow
(access gating is Okta's job, not this app's - roles/authorization stay
local), replaced "create the first admin" with the promote-not-create
bootstrap path (D16) and its no-break-glass posture, replaced the curl-based
login example in Quick Test with a pointer to smoketest.py's own
session-minting technique (there is nothing left to curl - Okta requires a
real browser).

DEPLOYMENT.md: same treatment for its own copies of the env block, the
Portainer var list, the users table's password_hash column, the auth
endpoints summary, the smoke-test walkthrough (WP_SMOKE_USER only, must run
inside the api container or local dev sharing AUTH_SECRET_KEY/DATABASE_URL -
no longer targetable from an arbitrary remote workstation), the entire
"Self-service password reset" section (replaced with "Sign-in and admin
bootstrap (Okta)"), and the project_super_user role description / exclusive-
scope bullet, both of which named "reset passwords" as something that no
longer exists.

Left alone, logged rather than fixed here per CLAUDE.md scope discipline:
- users.failed_attempts / locked_until columns are still in the schema and
  still reset to 0/None on every Okta sign-in, but nothing increments them
  anymore since local login() is gone - vestigial, not documented as active
  lockout behavior in either doc now, but not migrated away either.
- server/README.md's "Production - Docker Compose" section (### 1-5) is a
  self-contained alternate quickstart that already duplicated and diverged
  from the real root docker-compose.yml before this task; it uses env_file
  rather than an explicit allowlist so it isn't broken by this change, but
  it's still a second source of truth nobody asked this task to reconcile.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-03 13:47:48 -07:00
78d1942a0e T10.7 - add an explicit validation note (22/22, 26/26, 71/71) 2026-09-03 13:34:30 -07:00
45aff9c423 T10.7 - record the real browser-suite verification
url_state_check.py and browser_check.py both need a real headless browser via
tests/cdp.py, which the dev sandbox T10.7 was built in does not have and
cannot install (no sudo, network egress allowlisted against every route tried
- apt, a user-space Playwright Chromium download, Docker Hub). Documented as
an open gap in that commit rather than claimed as done.

Run for real since, on a machine with Docker, through a small general-purpose
tool kept deliberately outside this repo (headless-py-test-runner - it has no
idea what repo it is pointed at, so it does not belong in a Work Package Suite
PR). url_state_check.py 26/26, including scenario 2's actual click-through of
the fake-Okta round trip this task built; browser_check.py 71/71. Gap closed -
wave-10.md now says so instead of leaving the question open.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-03 13:33:17 -07:00
290c9b078c T10.7 - a fake-OIDC-provider test seam, mirroring ldap_fake.py
Only two calls actually touch the network: Authlib's authorize_redirect and
authorize_access_token. server/okta_fake.py stands in for both, dispatched from
okta_auth._build_oauth() before the real Okta config is even considered, and
production-refusing the same way ldap_fake.is_active() does - a non-SQLite
DATABASE_URL means production, full stop, no matter what WP_OKTA_FAKE_DIRECTORY
says. Everything this app itself decides stays real: the ?next= open-redirect
guard, the disabled-account check, JIT provisioning, and which claim carries
identity all run unmodified in app.py's okta_login()/okta_callback().

The fake needed one thing ldap_fake.py never did: something to actually redirect
the browser to and back, since Okta's real flow leaves the site and LDAP's never
did. Two routes stand in for Okta's own sign-in screen - a plain picker listing
whatever WP_OKTA_FAKE_DIRECTORY defines, and a consent step that hands back an
authorization code (or an error) at okta_callback, exactly the shape a real Okta
redirect would carry. Both are registered in app.py only when the fake is active
at import time, so in production they do not exist at all, not merely refuse a
request - confirmed by starting the app with the env var unset and checking
app.routes directly.

tests/browser_check.py's start_server() takes an optional extra_env now (no
existing caller passes a third positional arg, so none of the ~40 files that
import it needed touching) and sets WP_OKTA_FAKE_DIRECTORY unconditionally,
same reasoning the LDAP predecessor used: almost nothing signs in (seed() mints
tokens directly), but the one check that does should not fail mysteriously.

tests/url_state_check.py scenario 2, SKIPPED since T10.4, is un-skipped and now
drives the real round trip: login.html's own button, the fake picker page, the
fake consent redirect, okta_callback(). Carries forward the LDAP predecessor's
own bug fix too - asserting the app actually LEFT login.html, not just that
wp-creation-index.html appears somewhere in the URL (which the ?next= parameter
alone would satisfy).

tests/okta_auth_check.py is new, mirroring ldap_auth_check.py's two-layer shape:
guards that need no server (the production refusal, single-use/replay on the
authorization code), then a real running app for sign-in itself - an existing
admin surviving unchanged, JIT provisioning at the lowest role, a disabled
account refused despite Okta approving it, an unsolicited callback hit refused
without a 500, a tampered state refused, a denied consent refused, an unknown
identity refused BY THE SERVER (not just absent from the picker), a same-site
next= surviving and an off-site one ignored, and OKTA_IDENTITY_CLAIM genuinely
working under a non-default claim name. 22/22.

One thing this could not verify in this environment: url_state_check.py and
browser_check.py both need a headless Edge/Chrome via cdp.py, and this sandbox
has neither installed and no way to install one (no sudo). Confirmed the failure
is the tests' own designed-for exit 2 ("no headless-capable browser found; set
WP_BROWSER"), not a crash, and separately confirmed start_server() itself boots
cleanly with the fake wired in - health check, the picker page rendering with
the seeded identities, login.html all responding correctly - so the only gap is
the DOM-level click-through, not the server-side mechanism url_state_check
exercises (which okta_auth_check.py covers directly via HTTP instead).

wave-10.md's T10.7 bullet records the shape of what got built and the 22/22
result.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-03 12:11:24 -07:00
72b10283fc T10.5: login becomes an Okta redirect, not a form
server/app.py:
- okta_login(): validates and stashes ?next= (same-site path only) in the
  OAuth-state session before redirecting to Okta, so a deep link an assignment
  email carried (X1/CR-011/CR-014) survives the round trip instead of always
  landing on /index.html.
- okta_callback(): reads that stashed next= back (re-validated on the way out
  too - belt and suspenders against a crafted value) and redirects there on
  success. The two failure paths that used to raise a raw HTTPException -
  OAuthError (sign-in cancelled/failed) and a locally-disabled account - now
  redirect to /login.html?error=... instead: this route is reached by a full
  page browser navigation from Okta, not a fetch() call, so a JSON error body
  just looks like a broken page to whoever is signing in.

html/login.html + html/login.js: rebuilt as a single "Sign in with Okta" link,
replacing the username/password form and the forgot/reset-password views
(gone entirely - no local password exists to reset, per D15/D16/T10.4). Kept
the accessible error/ok banner pattern (role=alert / role=status) byte-for-
byte, since CLAUDE.md names this file as the reference other pages copy for
that pattern. login.js reads ?next= off its own URL (auth-guard.js's
goToLogin() already builds this, unchanged) and forwards it to
/api/auth/okta/login, and shows a plain-language message for ?error=disabled
/ ?error=cancelled, clearing the code from the address bar once shown. Sign-
out (auth-guard.js's wpLogout()) already redirected to login.html - untouched,
already satisfied "lands back on the app's own login page."

Uses a real <a href> rather than a JS-driven navigation, so it's a working
link even before login.js runs, and needs no keyboard/touch handling beyond
what a link gets for free (C1 accessibility).

Also fixed in passing (not a separate commit - this is what exposed it):
_safe_next_path() on the server and safeNext() in login.js enforce the exact
same rule (same-site path only, reject '//' and scheme URLs) so a crafted
?next= can't become an open redirect through a real Okta sign-in.

Verified: a fake-Okta-client round trip against the real app (SessionMiddleware
fix from the prior commit) confirms next= is honored end to end, a malicious
next= is rejected and falls back to /index.html, OAuthError redirects to
?error=cancelled, and a disabled account redirects to ?error=disabled. The
JS-side safeNext() was checked against the same cases directly in Node and
matches the server's validation exactly. login.js passes `node --check`;
login.html parses cleanly. Live 390px/1440px screenshots were NOT captured
this session - the environment's browser pane isn't signed in to view a
published preview of it, so that check needs to happen when this branch is
actually run and opened by a signed-in browser; the layout risk is low since
.card/.brand/.error/.ok/.foot are unchanged from the already-shipped file and
the only new CSS is one simple full-width block link.

wave-10.md T10.5 / D15 / D16
2026-09-03 11:27:26 -07:00
77f8f9f800 Fix T10.2: install SessionMiddleware, required by Authlib
okta_login() and okta_callback() (T10.2) both crash with a 500
(AssertionError: SessionMiddleware must be installed to access
request.session) against a real Okta client, because Authlib's
authorize_redirect() and authorize_access_token() both store/read OIDC
state and nonce in request.session. Never caught by T10.2's or T10.3's
own verification because every prior test mocked authorize_redirect /
authorize_access_token directly, bypassing Authlib's real implementation
entirely. Found while starting T10.5 and reproducing the real flow.

Adds starlette.middleware.sessions.SessionMiddleware, on its own cookie
(wp_oauth_state, distinct from the app's real session cookie wp_session)
with a short 10-minute lifetime and same_site=lax so it survives the
top-level redirect back from Okta. This cookie carries nothing but
ephemeral per-attempt OAuth state — no identity, no long-term secret —
so it reuses auth.SECRET_KEY rather than adding a new required config
knob. Reused in T10.5 to carry the post-login redirect target across
the same round trip.

Adds itsdangerous to requirements.txt — SessionMiddleware's hard
dependency, not previously needed anywhere in this app.

Verified: reproduced the crash against server.app with a fake (network-
bypassed) Authlib client and no SessionMiddleware, confirmed the
AssertionError, then confirmed the same request succeeds (302 to the
authorize URL, wp_oauth_state cookie set) once the middleware is added.

wave-10.md T10.2 (bug fix)
2026-09-03 11:13:28 -07:00
73da684b99 T10.4: remove the local password path entirely
Real deletion (D15's 'full replacement'), not a toggle. Okta is now the only
credential this app accepts anywhere.

Backend:
- server/models.py: drop User.password_hash.
- server/alembic/versions/1d60a608bb51_...: matching migration (op.drop_column,
  same plain-drop precedent as project_role/locked_until/etc.; downgrade re-adds
  it with server_default='').
- server/auth.py: remove hash_password/verify_password/password_problem/
  MIN_PASSWORD_LEN/_COMMON_PASSWORDS, create_reset_token/decode_reset_token/
  RESET_MINUTES, the bcrypt import. Roles/tokens/cookies/get_current_user
  untouched.
- server/app.py: remove login(), the whole self-service reset-password block
  (forgot-password/reset-available/reset-password), and change_password()
  (POST /api/auth/password). Rework create_user() to drop the password field
  (with a docstring note: the username must exactly match the eventual Okta
  identity claim, or a later sign-in provisions a second account instead of
  matching this one). Remove admin_reset_password() outright - nothing left to
  reset. Fixes a bug this task's own predecessor left behind: okta_callback()'s
  JIT provisioning (T10.3) was still setting password_hash="", which would have
  raised TypeError the moment the column was actually dropped.

Admin bootstrap (D16): server/manage_users.py moves from creating accounts
(create/create-admin/reset-password, all password-based) to a single 'promote
<username> --role <role>' command that changes the role on a row Okta's JIT
provisioning already created - the documented path for naming the first admin.
list/disable/enable unchanged.

Frontend: html/users.js drops the password field and validation from
createUser(), removes resetPw() and its button (nothing left to reset).
html/users.html drops the #nu-password input, adds a tooltip on username
explaining the exact-match-to-Okta requirement. html/auth-guard.js removes the
wpChangePassword dialog; html/wp-sidenav.js removes the 'Password' menu item
that opened it.

Tests: tests/browser_check.py and tests/launcher_check.py stop hashing a
password to seed fixture rows (and the --keep-server hint now prints a
ready-to-use cookie-setting snippet instead of a dead username/password).
tests/pipeline_check.py and tests/token_check.py drop an unused PW import.
tests/console_dialogs_check.py: the admin password-reset dialog it drove no
longer exists, so that scenario is removed - the prompt-with-validate() UI
pattern it exercised is still covered via creator_dialogs_check.py's
wp-creation-app.js call sites, noted in this file's docstring so the coverage
move isn't silent. tests/url_state_check.py: the "next= survives a real sign-in
via login" scenario is explicitly marked SKIPPED (not deleted, not faked) -
that promise is specific to the login FORM this task removed and can't be
honestly re-proven until T10.5 rebuilds it as an Okta redirect; a minted-token
cookie now stands in as setup only, so scenarios 3-6 in that file still get a
signed-in page to run against.

server/smoketest.py and server/seed_demo.py: switched from POST /api/auth/login
to minting a session the same way okta_callback() does (auth.create_token(),
seeded into the cookie jar) rather than waiting on T10.7. This is a real
operational change, documented in both files' own AUTHENTICATION sections: they
now need to run where AUTH_SECRET_KEY and the database match the target
server's (inside the api container, or local dev) - they can no longer sign in
to an arbitrary remote URL from an unrelated workstation, because Okta requires
a real browser and these are stdlib scripts. The account must already exist;
neither script creates or promotes one.

server/requirements.txt: bcrypt dropped, nothing imports it anymore.

Verified: full Alembic chain (baseline through this migration) upgrades and
downgrades cleanly against a throwaway SQLite DB. okta_callback() JIT
provisioning re-tested against the post-migration schema (would have thrown
before the password_hash="" fix above). create_user() verified via a live HTTP
call with no password field. manage_users.py promote verified end to end
(seed a JIT-shaped row at project_user, promote to admin, list). smoketest.py
and seed_demo.py both run to completion against a live uvicorn instance using
the new minted-session path - 25/25 checks, including logout actually
invalidating the session (proving the cookie-jar seeding didn't just fake the
sign-in, it preserved the real expiry mechanics).

wave-10.md T10.4 / D15 / D16
2026-09-03 10:58:28 -07:00
c74289aa0d D16: Okta admin bootstrap and break-glass posture; correct T10.4 scope
Decision, raised during T10.4 hazard review:

- Admin bootstrap: manage_users.py moves from creating an admin account to
  promoting an existing one, by username, on a row Okta's JIT provisioning
  (T10.3) already created. Rejected blind account creation — the exact
  OKTA_IDENTITY_CLAIM format is still unconfirmed by security, and a
  hand-typed username that doesn't match it produces an orphaned second
  account instead of promoting the real one. Ongoing (non-bootstrap) admin
  naming needs no new work: html/users.js's existing role dropdown already
  handles it.
- Break glass: none, by design, matching the precedent already on record
  for the abandoned LDAPS design (D13/D14) rather than assumed to carry
  over untested. If Okta is unreachable, the app is unreachable for
  everyone until Okta is restored. Rejected a toggleable emergency local
  login — it would reintroduce the stored credential D15 exists to
  eliminate.

Also corrects T10.4's scope in wave-10.md: hazard review found real call
sites of hash_password/verify_password/password_problem the original
bullet didn't name (create_user(), admin_reset_password(), users.js's
admin forms, browser_check.py/launcher_check.py fixtures), plus a
verification-gate ordering problem (smoketest.py and seed_demo.py
authenticate via POST /api/auth/login, which T10.4 removes, and both are
named explicitly in CLAUDE.md's verification section). Fixed by having
T10.4 switch both scripts to mint a session with auth.create_token()
directly, the same technique browser_check.py already uses, rather than
waiting on T10.7.

D16
2026-09-03 10:35:58 -07:00
7ed3cbec4c T10.3: identity matching and JIT provisioning for Okta sign-in
okta_callback() now completes the sign-in instead of stopping at the claim:

- Matches the OKTA_IDENTITY_CLAIM value to a local account via
  auth.find_user() (username or email, case-insensitive) — the same lookup
  login() already uses, so an account whose username mirrors its AD
  identity needs no migration.
- No match: JIT-provisions a new account at the lowest-privilege role
  (project_user), no project membership, no password hash. Access beyond
  that is still granted locally by an admin/project super user, same as
  any account created by hand via create_user(). Logs a user_created audit
  event (via: okta_jit) for parity with that route.
- Match found but is_active is False: blocked with the same 403 'Account
  is disabled' login() raises today. Okta granting the challenge does not
  override an account this app has disabled locally (D15: 'roles stay
  local').
- On success: issues the same session cookie login() does (auth.create_
  token / auth.set_session_cookie), then redirects the browser to
  /index.html — this route is reached by a full-page navigation from
  Okta's redirect, not a fetch call, so a redirect is required rather than
  the JSON body login() returns.

Verified with a fake Okta client against a throwaway SQLite DB: new
identity provisions correctly (role/email/name/no-password), a repeat
sign-in matches the existing row without duplicating it or touching a
role an admin has since changed, a locally-disabled account is blocked
despite a valid Okta claim, and a missing identity claim is rejected
before touching the database.

wave-10.md T10.3 / D15
2026-09-03 10:16:50 -07:00
a9e5ee3892 T10.2: Okta login-redirect and callback routes
Adds GET /api/auth/okta/login (redirect to Okta's authorize endpoint) and
GET /api/auth/okta/callback (exchange code, validate ID token, pull the
identity claim) to server/app.py, using the oauth.okta client from
okta_auth.py (T10.1).

Access gating is Okta's job, not this route's: only accounts assigned to
the app integration in Okta ever reach the callback, so there is no
app-side group/claim check layered on top (D15, wave-10.md T10.2).

Stops at NotImplementedError once the identity claim is in hand. Matching
that claim to a local account and issuing the session cookie is T10.3, kept
separate per the one-task-per-PR rule.

wave-10.md T10.2 / D15
2026-09-03 10:11:49 -07:00
0ee35ae4ed T10.1: Okta OIDC client dependency and config (wave 10) 2026-09-03 09:57:55 -07:00
044862acba Wave 10: task breakdown for the Okta OIDC build 2026-09-02 17:38:35 -07:00
31c548318b D15: retire D13/D14 (LDAPS, never deployed), move straight to Okta OIDC 2026-09-02 17:20:01 -07:00
8f117680b0 Merge branch 'fix/alembic-transaction-per-migration': truthful migration logs
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-09-01 15:35:36 -07:00
6034c08bad Alembic runs one transaction PER MIGRATION, not one for the whole chain
The 2026-08-21 crash at material_items printed 'Running upgrade' lines for
location_nodes and wp_files and then rolled all three back together - env.py
wrapped the entire run in a single transaction. The repair that followed
trusted those lines: material_items was hand-created, the version stamped to
head, and production ran for two days missing two tables it claimed to have.
Found 2026-08-23 when the locations import 500'd on UndefinedTable.

transaction_per_migration=True makes the log truthful: a crash keeps every
step that completed, and a stamp-to-head repair after a crash repairs ONE
migration, not an unknowable prefix of the chain. Verified: the full chain
still applies on a fresh scratch SQLite; the offline --sql render is
unchanged.

The production surgery (creating the two rolled-back tables from the offline
postgres render) is recorded in the session; no version stamp is needed
there - it is already, now truthfully, at head.

Items: BL-027's class, third finding; env.py infrastructure.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-09-01 15:35:36 -07:00
17cabbd032 Merge branch 'fix/import-row-hazards': imports reject rows, never 500
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-09-01 15:26:38 -07:00
222c0b1c29 CR-005/D6 fix - a bad CSV row rejects by line number instead of 500ing Postgres
Nick's real location list hit the production import and got 'Internal Server
Error' with no line number - BL-027's class again, three days after the
migration outage: Postgres enforces VARCHAR lengths and refuses control
bytes, SQLite shrugs at both, and the importers were only ever rehearsed on
SQLite. Reproduced both hazards locally (an over-long value and a NUL byte
import cleanly on SQLite; either 500s Postgres wholesale).

Both importers now validate per row, before any INSERT, so every dialect
answers the same way - with the line number and a reason:
- locations: control characters; names over 200; codes over 60; combined
  paths over 200 (checked where the path exists, with read-counts taken
  before the loop so a mid-loop rejection is not counted twice)
- materials: control characters; description/unit/code over 300/20/80

And the client stops lying about it: wp-list-import.js read every response
with r.json(), so a plain-text 500 threw mid-parse and surfaced as 'Could not
reach the server' while the server was answering fine. One tolerant reader
(text -> parse if it parses -> keep status) now serves import, add and patch;
a real error reads 'Import refused - HTTP 500'.

Pins: materials_check +2 (over-long and control-byte rows reject at line,
20/20), locations_check +1 (over-long name rejects at line, 59/59).

Items: CR-005, D6, BL-027 (second instance of its class; the probe-side
dialect guard it proposes is still open).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-09-01 15:26:37 -07:00
e31234beef Merge branch 'docs/bl-026-027': the outage's two lessons, backlogged
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-08-21 12:20:32 -07:00
6057d05b98 BL-026 / BL-027 - the two lessons of the Aug 21 outage, logged
BL-026: no version stamp - 'is live current?' took mid-outage fingerprinting;
the fix shape is a git SHA baked at build, served by /api/health, shown on
the admin diagnostics card (D13 candidate).

BL-027: migrations rehearsed on SQLite only - the dialect drift class behind
the outage stays unguarded beyond the one pinned instance; the fix shape is
an offline postgresql-dialect render in the runbook and/or a probe.

Items: backlog only, no code.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-08-21 12:20:30 -07:00
64eac0cbbb Merge branch 'fix/material-items-boolean-default': the Postgres deploy hotfix
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-08-21 12:05:27 -07:00
101 changed files with 11175 additions and 1490 deletions

10
.env.local.example Normal file
View File

@@ -0,0 +1,10 @@
# Copy to .env in the repository root for a local Docker run (T13.8).
# .env is ignored by git. Use values that are not used anywhere else.
POSTGRES_USER=wpsuite
POSTGRES_PASSWORD=local-only-change-me
POSTGRES_DB=wpsuite
# Generate: python -c "import secrets; print(secrets.token_urlsafe(48))"
AUTH_SECRET_KEY=local-only-change-me-to-a-long-random-string
# Rehearse the Okta sync first. Add OKTA_API_TOKEN and OKTA_ORG_URL only when you
# want the local stack to call the real Okta, and keep this on until you read the log.
OKTA_SYNC_DRY_RUN=true

View File

@@ -24,7 +24,7 @@ In the stack's **Environment variables** section, add:
| Name | Value | Notes |
|------|-------|-------|
| `AUTH_SECRET_KEY` | a long random string | **Required.** Signs the login session cookies. |
| `AUTH_SESSION_HOURS` | `12` | *Optional.* Hours a login lasts before re-auth (defaults to 12). |
| `AUTH_SESSION_HOURS` | `8` | *Optional.* Hours a login lasts before re-auth (defaults to 8). |
Generate the secret on the host with:

View File

@@ -0,0 +1,355 @@
# Deploy runbook: WP Suite Okta cutover (wave 10)
**For:** IT / whoever administers the Docker host and Portainer
**From:** m.mabrey@prime-controls.com
**Revised:** 2026-09-03. First version of this runbook.
**Expected duration:** 20-30 minutes, including the backup and the live sign-in check
**Expected downtime:** under a minute, while containers are recreated
This is a separate runbook from `DEPLOY-runbook-2026-08-04.md`, not a revision of it.
That one still applies to its own deploy. Read this one in full before starting.
It has a step that the earlier one does not: this deploy removes the local password
system entirely, and one part of that removal cannot be undone by the usual means.
See "What this deploy changes" below.
---
## Fill these in before handing this over
| Thing | Value |
|---|---|
| Docker host (SSH target) | `________________` |
| Stack name in Portainer | `________________` |
| Site URL | `https://________________` |
| Stack directory on the host (holds `docker-compose.yml` / `backups/`) | `________________` |
| A real Okta account assigned to the app integration, for the live check in Step 4 | `________________` |
Container names are fixed by the compose file and are the same on every host:
`nginx_webserver`, `wp_api`, `wp_db`, `wp_db_backup`.
---
## What this deploy changes
Sign-in changes from a local username/password to Okta OIDC, completely. Not a
toggle, not a fallback. Three things make this more than a routine deploy:
1. **Five new environment variables are required**, and without them nobody can
sign in: `OKTA_ISSUER`, `OKTA_CLIENT_ID`, `OKTA_CLIENT_SECRET`,
`OKTA_REDIRECT_URI`, and optionally `OKTA_IDENTITY_CLAIM`. This is a genuine
change from how deploys usually go here. Do not skip Step 1.5.
2. **A migration drops the `password_hash` column** (`1d60a608bb51`), and it is
**one-way in practice.** Its `downgrade()` re-adds the column, but empty.
The real password hashes are gone the moment this commits, and no `alembic
downgrade` brings them back. If this deploy needs to be undone after that
point, going back to the old local-password code does not work on its own.
See the Rollback section, Case C. This is why Step 1's backup is not
optional the way it sometimes reads in other runbooks.
3. **There is no break-glass path**, by design (recorded decision D16). If Okta
is unreachable or misconfigured after this deploy, the app is unreachable for
everyone, admins included, until Okta is fixed. That is expected behavior,
not a bug to roll back from. See Rollback, Case A/B, before assuming
something is broken.
The visible change for people using the app: the login page becomes "Sign in
with Okta" instead of a username/password form. Nothing else in the app's
day-to-day behavior changes.
---
## Step 0: Record the current state (needed for rollback)
SSH to the Docker host and run:
```bash
docker exec wp_api alembic -c server/alembic.ini current
docker inspect nginx_webserver --format 'nginx image: {{.Image}}'
docker inspect wp_api --format 'api image: {{.Image}}'
```
**Copy the output into your ticket.** Also note the Git commit the Portainer
stack is currently on (Portainer, the stack, the Git reference / last-updated
commit). Without these, rollback is guesswork.
Expected output of the first command before this deploy: `a1b8c6d4e2f9 (head)`.
If it shows anything else, stop and check with me before continuing. This
runbook assumes that starting point.
---
## Step 1: Back up the database
On the Docker host:
```bash
docker exec wp_db_backup /scripts/db-backup.sh
```
Expected output ends with a line like:
```
[db-backup] wrote 1.4M /backups/wpsuite-20260903-141233Z.sql.gz.enc
```
Confirm the file is on the host (substitute the stack directory):
```bash
ls -lt <stack-dir>/backups | head -3
```
**Record that filename.** Do not continue until you have seen the `wrote ...`
line and the file in that listing.
This backup matters more than usual for this deploy. Once the migration in
Step 3 commits, this file becomes the *only* way to get local password hashes
back, for any reason. Treat it as the point you would restore to, not routine
housekeeping.
- A `.sql.gz.enc` extension means backups are encrypted. Expected and correct.
- A `.sql.gz` extension plus a `WARNING: BACKUP_ENC_PASSPHRASE not set` line
means backups are unencrypted. Not a blocker for this deploy; report it back.
- **No SSH access?** Portainer, **Containers**, `wp_db_backup`, **Console**,
connect with `/bin/sh`, then run `/scripts/db-backup.sh`. Same result: the
dump lands on the host, because `/backups` is a bind mount.
---
## Step 1.5: Confirm the Okta app integration is actually ready
Do this before redeploying, not after. Everything here is checked in Okta's own
admin console and in the values that will go into the stack's environment
variables. Nothing touches the WP Suite host yet.
1. The Okta app integration exists (Sign-in method: OIDC, Authorization Code,
Application type: Web Application), and the account listed in the fill-in
table above is assigned to it.
2. `OKTA_REDIRECT_URI` matches a "Sign-in redirect URI" registered on that app
integration **exactly**: scheme, host, and path, including whether it ends
in `/api/auth/okta/callback`.
3. `OKTA_ISSUER`, `OKTA_CLIENT_ID`, and `OKTA_CLIENT_SECRET` are the values from
that same app integration, not a different one.
4. If your Okta configuration puts the directory identity somewhere other than
the `preferred_username` claim, `OKTA_IDENTITY_CLAIM` is set to the right
claim name. If unsure, leave it unset; `preferred_username` is the default.
Add all five to the stack's **Environment variables** in Portainer now, before
Step 2. `OKTA_CLIENT_SECRET` should be handled the same way `AUTH_SECRET_KEY`
already is: not typed anywhere it will be logged.
If any of items 1-3 above are not yet confirmed, stop here and get them
confirmed first. A wrong redirect URI or an unassigned account will not corrupt
anything, but it does mean nobody signs in after this deploy until it is fixed.
See Rollback, Case B, which is the ordinary way that gets fixed and does not
involve the database at all.
---
## Step 2: Redeploy the stack in Portainer
1. Portainer, **Stacks**, select the stack.
2. **Pull and redeploy**, with re-pull / re-build **enabled**.
3. Wait for it to report success.
A plain "restart" or "stop/start" will not pick up new code, and will not pick
up the environment variables added in Step 1.5 either.
---
## Step 3: Confirm the containers came up
```bash
docker ps --filter name=nginx_webserver --filter name=wp_api --filter name=wp_db
```
All three must be `Up`, and `wp_db` should show `(healthy)`. Then check the API
applied its migration cleanly:
```bash
docker logs wp_api --tail 40
```
You are looking for an Alembic `Running upgrade a1b8c6d4e2f9 -> 1d60a608bb51`
line followed by gunicorn starting up, and no traceback. The API refuses to
start if a migration fails, so a restarting `wp_api` container means it failed.
Go to Rollback, Case B, and read the "did the migration commit" note there
before doing anything to the database.
Confirm the database landed on the new revision:
```bash
docker exec wp_api alembic -c server/alembic.ini current
```
Expected: `1d60a608bb51 (head)`. **Once you see this, you have passed the
point of no return described above.** The backup from Step 1 is now the only
way back to a working local-password system, if that is ever needed.
Then verify nginx's own view of its config:
```bash
docker exec nginx_webserver nginx -t
```
Expected: `syntax is ok` / `test is successful`.
---
## Step 4: Confirm Okta sign-in actually works, live
This is the step that matters most for this deploy. A clean container start
does not by itself prove sign-in works, and there is currently no startup log
line that confirms Okta config is good (logged separately as a follow-up, not
fixed as part of this runbook). The only real proof is a live sign-in.
1. Open the site's normal URL in a private/incognito window. It should land on
`login.html` with a "Sign in with Okta" button, not a username/password
form.
2. Click it. You should be redirected to your organization's actual Okta
sign-in page (the real Okta domain from `OKTA_ISSUER`, not this app's own
domain).
3. Sign in with the account from the fill-in table. You should land back on
the WP Suite site, signed in.
4. If this is the account's first-ever sign-in, it is now JIT-provisioned as a
regular user (`project_user`). To make it an admin, on the Docker host:
```bash
docker exec -it wp_api python -m server.manage_users promote <username> --role admin
```
This only works on an account that has already signed in once through Okta.
It promotes an existing row; it does not create one. That is deliberate
(recorded decision D16): there is no other admin-bootstrap path.
If step 2 or 3 fails (redirected to an Okta error page, redirected back to
`login.html` with an error, or nothing happens), this is almost always a
configuration problem from Step 1.5, not a code or database problem. Go to
Rollback, Case B, before considering anything more drastic.
Also confirm the API is reachable through the proxy and the redirect itself is
wired up:
```bash
curl -s https://<site-url>/api/health # -> {"ok": true}
curl -sI https://<site-url>/api/auth/okta/login | grep -i ^location # -> your Okta authorize URL
```
---
## Step 5: Hard-reload once in a browser, then sanity-check
Press **Ctrl+Shift+R** (Cmd+Shift+R on macOS) once. The app uses a service
worker; a normal reload can serve the previous version.
1. Signed in as the account from Step 4, the home page offers to select or
create a project, same as before.
2. Open **Admin Console** as the promoted admin account. The user table shows
the account you just signed in with. There is no password column, no
"reset password" action anywhere in the UI.
3. Open a project and confirm a work package can be opened and edited
normally. Sign-in is the only thing this deploy changes, so the rest of
the app should look untouched.
**Deploy complete.** Please report back: the Step 0 output, the backup
filename from Step 1, and confirmation that Step 4's live sign-in worked.
---
## Rollback
Read this before assuming a rollback is needed. Cases A and B below do **not**
touch the database and are the far more likely outcome of something going
wrong here. Okta configuration is fiddly and easy to get slightly wrong. Case
C is the severe, destructive one, and should be a last resort, not a first
reaction.
### Case A: nginx won't start, or containers won't come up at all
Same as any other deploy: the database is untouched by container start-up
failures. In Portainer, redeploy the stack pinned to the **previous Git
commit** recorded in Step 0, then re-run Step 3.
```bash
docker logs nginx_webserver --tail 100
docker logs wp_api --tail 100
```
Send me whichever of those is relevant.
### Case B: containers are up, but Okta sign-in doesn't work
This is a configuration problem, not a data problem, and does **not** need a
code rollback or a database restore. Check, in order:
1. Is `wp_api`'s log showing anything at all when a sign-in is attempted?
`docker logs wp_api --tail 100`.
2. Do the five `OKTA_*` values in the stack's environment variables actually
match the Okta app integration (Step 1.5)? A copy-paste error in
`OKTA_CLIENT_SECRET` or a redirect URI that's off by a trailing slash are
the two most common causes.
3. Is the account assigned to the Okta app integration? An unassigned account
gets denied by Okta itself, before it ever reaches this app.
4. If a specific person can't sign in but others can, check
`OKTA_IDENTITY_CLAIM`. The claim it reads may not carry that person's
directory identity in the format expected. Confirm with security which
claim Okta is actually issuing.
Fix the environment variable(s) in Portainer, then redeploy (Pull and redeploy
is fine; the migration already applied and does not run again). No backup
restore, no code rollback.
If it's still not working after checking all four, send me the `wp_api` log
from item 1 along with which of items 2-4 you already ruled out.
### Case C: the decision is made to abandon Okta and restore local-password sign-in
This is the case the point-of-no-return warning in "What this deploy changes"
is about. Only reach for this if Case A and B do not apply. That is, Okta
itself is working correctly but a decision has been made to go back to the old
system entirely.
**This cannot be done with a code rollback alone.** The old code expects a
real `password_hash` on every user row. After Step 3 commits, that column is
either gone or (if `alembic downgrade` is run) present but empty. Either way,
nobody's stored password survived, including admins'. The only way to get a
working local-password system back is to restore the full database from the
Step 1 backup, which also rolls back every other change made since that
backup: new work packages, comments, uploaded files, everything.
**Do not do this without confirming with me first.** If it is confirmed, for
an encrypted dump, on the Docker host, in the `backups` directory:
```bash
export BACKUP_ENC_PASSPHRASE='<the passphrase, from the stack env vars>'
openssl enc -d -aes-256-cbc -pbkdf2 -pass env:BACKUP_ENC_PASSPHRASE \
-in wpsuite-<timestamp>.sql.gz.enc \
| gunzip \
| docker exec -i wp_db psql -U wpsuite -d wpsuite
unset BACKUP_ENC_PASSPHRASE
```
For an unencrypted dump, drop the `openssl` stage and pipe `gunzip` straight
into `psql`. Substitute the real values if `POSTGRES_USER` / `POSTGRES_DB` are
not `wpsuite`. After restoring, redeploy pinned to the Git commit recorded in
Step 0, since the restored database matches the old schema, not this one.
Reach me at m.mabrey@prime-controls.com.
---
## Notes
- Do not run `docker compose down -v`. The `-v` flag deletes the `pgdata`
volume and with it the entire database.
- `docker exec <container-name>` is used throughout rather than
`docker compose ...`, because a Portainer-managed Git stack's compose project
lives under Portainer's own data directory and usually isn't reachable from
an ad hoc SSH session the same way.
- There is currently no startup log line confirming Okta config is valid
(`okta_auth.describe()` exists but nothing calls it yet, logged as a
follow-up). Step 4's live sign-in is the real verification until that's
wired in.
- Full background documentation: `DEPLOYMENT.md` and `server/README.md` in the
repository. `docs/waves/decisions-2026-09-03.md` (D16, D17) records why
there is no break-glass path and why this runbook exists as its own document.

View File

@@ -52,27 +52,44 @@ POSTGRES_DB=wpsuite
POSTGRES_USER=wpsuite
POSTGRES_PASSWORD=<strong-random-password>
# REQUIRED — signs login session cookies. If unset, `docker compose up` errors
# out and the API refuses to start. Generate once and keep it stable:
# REQUIRED — signs login session cookies, AFTER Okta has confirmed who someone
# is. If unset, `docker compose up` errors out and the API refuses to start.
# Generate once and keep it stable:
# openssl rand -base64 48
AUTH_SECRET_KEY=<strong-random-secret>
# REQUIRED (in spirit — see the note below) — Okta OIDC is the only sign-in
# path (D15/D16). There is no local password anywhere in this app to fall back
# to, so without these nobody can sign in at all. Get them from the Okta app
# integration (sign-in method OIDC - Authorization Code, Web Application):
#
# OKTA_ISSUER the authorization server, e.g.
# https://your-org.okta.com/oauth2/default
# OKTA_CLIENT_ID \_ from the app integration
# OKTA_CLIENT_SECRET /
# OKTA_REDIRECT_URI must exactly match a "Sign-in redirect URI"
# registered on the app integration, e.g.
# https://wp-suite.company.local/api/auth/okta/callback
#
# Full explanation, and the optional OKTA_IDENTITY_CLAIM override, in
# server/.env.example. Not enforced at startup the way AUTH_SECRET_KEY is —
# the API starts without these, it just refuses every sign-in and says so in
# `docker compose logs api` (server/okta_auth.py's describe()).
OKTA_ISSUER=<https://your-org.okta.com/oauth2/default>
OKTA_CLIENT_ID=<from the Okta app integration>
OKTA_CLIENT_SECRET=<from the Okta app integration>
OKTA_REDIRECT_URI=<https://your-hostname/api/auth/okta/callback>
# Encrypts database backups at rest (AES-256). Set this BEFORE the DB holds
# customer IP. Keep the passphrase OFF this host — losing it makes dumps
# unrecoverable: openssl rand -base64 32
BACKUP_ENC_PASSPHRASE=<strong-random-passphrase>
# OPTIONAL — SMTP password for WP-assignment email + password-reset links. Email
# is OFF by default and enabled from the Admin console; the host/port/from-address
# are configured there, but the password is only ever read from this variable
# (never stored in the DB or shown in the UI). Leave unset until you have SMTP
# details.
# OPTIONAL — SMTP password for WP-assignment email. Email is OFF by default and
# enabled from the Admin console; the host/port/from-address are configured
# there, but the password is only ever read from this variable (never stored
# in the DB or shown in the UI). Leave unset until you have SMTP details.
# SMTP_PASSWORD=<smtp-app-password>
# OPTIONAL — password-reset link lifetime (minutes) and the per-account send
# cooldown (seconds). Defaults shown; both only matter once email is enabled.
# AUTH_RESET_MINUTES=60
# AUTH_RESET_COOLDOWN_SECONDS=120
```
The API builds its own DB connection string from the `POSTGRES_*`
@@ -87,6 +104,7 @@ Generate a strong password with `openssl rand -base64 32`.
> **Portainer note:** for a Git-based stack these go in the stack's
> **Environment variables** section (Portainer doesn't read a local `.env`).
> Set `POSTGRES_DB` / `POSTGRES_USER` / `POSTGRES_PASSWORD` / `AUTH_SECRET_KEY` /
> `OKTA_ISSUER` / `OKTA_CLIENT_ID` / `OKTA_CLIENT_SECRET` / `OKTA_REDIRECT_URI` /
> `BACKUP_ENC_PASSPHRASE` (and `SMTP_PASSWORD`, if you enable email) there.
These are the only credentials in the system, and they never appear in the
@@ -151,25 +169,34 @@ project → SOP → Work Package → the AWP issue gate → status → metrics
archive round trip → cascade cleanup → sign-out). Stdlib only — no pip/jq.
It **signs in first**, because every `/api/` route except `/api/health` requires a
session. Credentials come from the environment so a password stays out of shell
history, and the account must be an **admin**: the run creates a project and deletes
it again, and archiving or deleting one takes Project Admin on it. The script checks
the signed-in role up front and warns if it is too low rather than letting you find
out in the cleanup step.
session — but there is no local password to sign in with (D15/D16), and Okta
requires a real browser to complete, which this script cannot do. So instead
of an HTTP login, it mints a session directly the same way `okta_callback()`
does after Okta hands back an identity, which means **it has to run somewhere
that can read the same `AUTH_SECRET_KEY` and reach the same database as the
server under test** — inside the `api` container, or local dev against your
own DB. It can no longer sign in to an arbitrary remote URL from an unrelated
workstation the way the old password-based version could.
The account named by `WP_SMOKE_USER` must **already exist** — sign it in
through Okta once first, or pre-create it from the User Directory — and must
be an **admin**: the run creates a project and deletes it again, and deleting
one takes Project Admin on it. The script checks the signed-in role up front
and warns if it is too low rather than letting you find out in the cleanup
step.
```bash
export WP_SMOKE_USER=<admin-account>
export WP_SMOKE_PASSWORD='…'
# Through the proxy (use --insecure for a self-signed internal cert):
python3 server/smoketest.py https://wp-suite.company.local --insecure
# Or from inside the api container (hits FastAPI directly). Pass the vars through:
docker compose exec -e WP_SMOKE_USER -e WP_SMOKE_PASSWORD api \
# From inside the api container — has AUTH_SECRET_KEY and DATABASE_URL, and
# hits FastAPI directly. This is the normal way to run it in production:
docker compose exec -e WP_SMOKE_USER api \
python /app/server/smoketest.py http://localhost:8000
# Local dev, against the app you're running yourself:
export AUTH_SECRET_KEY=... DATABASE_URL=... WP_SMOKE_USER=<admin-account>
python3 server/smoketest.py http://localhost:8000
# Add --keep to leave a demo project in the DB so you can open it in the UI.
# --user / --password override the environment if you'd rather be explicit.
# --user overrides $WP_SMOKE_USER if you'd rather be explicit.
```
Exit codes: **0** all checks passed · **1** one or more checks failed · **2** the run
@@ -257,7 +284,7 @@ users on the same project see the same server-stored SOP and Work Packages.
| `sops` | project SOP baselines | `project_id` → projects, `name`, `number`, `complete`, `data` (full SOP JSON) |
| `work_packages` | individual IWPs | `project_id` → projects, `sop_id` → sops, `parent_id` (split instances), `number`, `subject`, `type`, `status`, `assignee_id` (owner), `issued_at`, `archived_at`, `data` (full WP JSON) |
| `comments` | feedback from any page | `source`, `sop_id`, `wp_id`, `step`, `author`, `text`, `extra` |
| `users` | login accounts | `username`, `password_hash` (bcrypt), `role`, `full_name`, `email`, `is_active`, `auto_add_projects` + `auto_add_role` (default membership on new projects), login-lockout + `token_version` fields |
| `users` | login accounts | `username` (matched against Okta's identity claim — no password column; D15/D16), `role`, `full_name`, `email`, `is_active`, `auto_add_projects` + `auto_add_role` (default membership on new projects), `token_version` |
| `project_members` | per-project access control | `user_id` → users, `project_id` → projects |
| `audit_log` | append-only activity trail | `actor`, `action`, `entity_type`, `entity_id`, `project_id`, `summary`, `detail` |
| `notifications` | in-app record + email outbox | `user_id`, `kind`, `wp_id`, `subject`, `status` (pending / sent / failed / skipped) |
@@ -275,8 +302,9 @@ Work Packages `GET/POST /api/wps`, `GET/DELETE /api/wps/{id}`,
`POST /api/wps/{id}/issue`, `POST /api/wps/{id}/status`, `POST /api/wps/{id}/archive`,
`GET /api/wps/metrics` ·
Comments `POST /api/comments` (and `/api/feedback`), `GET /api/comments` ·
Auth `POST /api/auth/login` / `logout`, `GET /api/auth/me`, admin user management
under `/api/auth/users` (including `POST /api/auth/users/{id}/auto-add`) ·
Auth `GET /api/auth/okta/login` / `okta/callback` (the Okta sign-in round trip),
`POST /api/auth/logout`, `GET /api/auth/me`, admin user management under
`/api/auth/users` (including `POST /api/auth/users/{id}/auto-add`) ·
Admin-only `GET/PUT /api/settings`,
`POST /api/settings/test-email`, `GET /api/notifications`,
`GET /api/projects/{id}/members`.
@@ -350,27 +378,173 @@ TLS / From address and flips the master toggle.
package contents — so customer IP stays behind the login.
- Use the card's **Send test email** button to confirm SMTP before enabling.
### Self-service password reset
### Sign-in and admin bootstrap (Okta)
Turning email on also enables **Forgot password** on the login page. Until then the
link explains that an admin must reset it (`server/manage_users.py`, or the Admin
console's **Reset password** button).
There is no local password anywhere in this app — no "Forgot password," no
reset link, nothing email-related to sign-in (D15/D16). `SMTP_PASSWORD` above
is purely for WP-assignment notification emails.
- The emailed link carries a short-lived signed token — `AUTH_RESET_MINUTES`
(default 60). It is **single-use**: completing a reset bumps the account's
`token_version`, which both burns the link and signs out that user's other
sessions. A completed reset also clears any login lockout.
- `/api/auth/forgot-password` answers **identically for unknown accounts**, so it
can't be used to discover usernames. Misses are recorded in the audit log
(`password_reset_miss`) instead.
- One reset mail per account+client per `AUTH_RESET_COOLDOWN_SECONDS` (default 120)
so the form can't be used to flood someone's inbox. The throttle is per worker
and in-memory; the token expiry is the real control.
- Reset mails are sent **immediately, not through the notifications outbox** — a
reset link must never be persisted where an admin could read it and take over an
account.
- Set `app_base_url` in the admin card, or the emailed link will be relative and
therefore useless.
Sign-in is entirely Okta's job: `login.html` redirects to Okta, and access
control is **who is assigned to the app integration in Okta** — see step 2's
`OKTA_*` variables and [`server/README.md`](server/README.md#sign-in-okta) for
the full flow. The first admin has to sign in through Okta once (landing as an
ordinary `project_user`, auto-provisioned), then get promoted from a shell:
```bash
docker compose exec api python -m server.manage_users promote alice --role admin
```
This is deliberate, not an oversight: a hand-typed username at account-creation
time risks a second, orphaned row if it doesn't exactly match what Okta sends,
so the CLI promotes an existing Okta-provisioned row rather than creating one
blind (D16). Every admin after the first can be promoted from the User
Directory page — no shell access needed.
**No break-glass path.** If Okta is unreachable or misconfigured, the app is
unreachable for everyone, including admins, until Okta is restored — the same
posture the abandoned LDAPS design took, carried forward deliberately (D16).
### Accounts the Okta sync disabled (D18)
**Who this is for:** app admins, and project super users who manage accounts.
When Okta credentials are set (`OKTA_API_TOKEN`, or the service-app pair below), the `api` container asks Okta every 15 minutes
(`OKTA_SYNC_INTERVAL_SECONDS`) who is still active. It **disables** a local
account when the person is missing from Okta's list, or when Okta shows the
status SUSPENDED or DEPROVISIONED. A password expiry, a lockout, or a recovery
in progress does not disable anyone. With no token set, the sync is off and the
startup log says `Okta sync DISABLED`.
**Two ways to sign in to Okta.** Set one of them.
- *API token (SSWS):* set `OKTA_API_TOKEN` to the token string. It has about 40
letters, digits, hyphens and underscores, and no quote marks.
- *Service app with a private key (`private_key_jwt`):* set `OKTA_SYNC_CLIENT_ID`
(the app's client ID, it starts with `0oa`) and `OKTA_SYNC_PRIVATE_KEY` (the
private key as a JWK). The key starts with `{` and has fields such as `kty`,
`kid` and `d`. In Portainer, encode it as base64 first, because Portainer can
change the quote marks in JSON. In Windows PowerShell, save the key to a file
`key.json` and run:
[Convert]::ToBase64String([IO.File]::ReadAllBytes("key.json"))
Paste the one-line result as the value. Delete `key.json` afterward. The key is
a secret: never put it in Git, a ticket, or a chat.
The Okta admin must set up the app as follows: the app type is API Services; the
scope `okta.users.read` is granted on the Okta API Scopes tab; an admin role
that can read users (for example Read-only Administrator) is assigned to the app.
DPoP can be on or off. By default (`OKTA_SYNC_DPOP=auto`) the sync asks for a plain
token first, and if Okta answers `invalid_dpop_proof` it uses DPoP. Set
`OKTA_SYNC_DPOP` to `on` or `off` only to force one way. If both
`OKTA_API_TOKEN` and the service-app pair are set, the token is used.
The startup line in the log says which credential is in use. A failed sign-in
shows the HTTP status and the Okta error code, for example
`Okta answered HTTP 400 to the token request, error invalid_scope`. Common codes:
`invalid_client` (wrong client ID or key, or the key is not registered on the app),
`invalid_scope` (the scope is not granted), `access_denied` (no admin role assigned), `invalid_dpop_proof` (DPoP was used and Okta
rejected the proof: send the log lines to the developer), `use_dpop_nonce` (Okta kept
asking for a new nonce).
**First deploy: use the dry run.** Set `OKTA_SYNC_DRY_RUN=true` in `.env` (or the
Portainer stack environment) with the token, then run `docker compose up -d --build api`.
The sync runs as normal but changes no account and writes no audit row. Read the
result:
docker compose logs api | grep "Okta sync"
The summary line shows how many Okta users and active local accounts it checked,
how many matched, and how many it would disable. A line `DRY RUN would disable ...`
names each account. If the match count is close to your number of real users and
the list holds only people who have left, remove `OKTA_SYNC_DRY_RUN` (or set it
to `false`) and run `docker compose up -d api` again to go live. If the match
count is low, the Okta attribute is wrong. Set `OKTA_SYNC_PROFILE_ATTRIBUTE`
and run the dry run again.
The sync only ever disables. **It never re-enables an account.** A person comes
back only when an admin enables the account by hand.
**How to see what the sync did**
1. Open the **Admin Console** (`admin.html`). Find the **Activity log** card.
2. Click **Refresh**. Search for `okta_sync`, or set the type to **User accounts**.
3. A row from the sync reads: Who `system:okta_sync`, Action `user deprovisioned
by sync`, Item the username, Detail `okta_status: SUSPENDED` (or `MISSING` if
the person was not in Okta's list at all).
Only app admins see these rows. They belong to no project.
**How to re-enable a person**
1. **Fix the person in Okta first.** Ask the Okta admin to make the person ACTIVE
again (or to restore them, for a rehire). If you skip this step, the next sync
cycle (up to 15 minutes later) disables the account again.
2. Open the **User Directory** (`users.html`).
3. Find the person. A disabled account shows the **Enable** button on its row.
Click it.
4. The person can sign in on their next attempt. The app writes a `user enabled`
row to the Activity log under your name.
**Who may do step 3**
* An **app admin** may enable any account.
* A **project super user** may enable an account only if every project the person
belongs to is a project that super user administers. If the person is also on a
project that the super user does not administer, the row is read-only and shows
the reason. An app admin must make the change.
* Nobody can change their own account.
**If no admin can sign in** (for example, a bad sync run disabled every admin),
use the shell on the host. Replace `alice` with the username:
```bash
docker compose exec api python -m server.manage_users list
docker compose exec api python -m server.manage_users enable alice
```
**If the sync disabled the wrong people**
1. Turn the sync off. Remove `OKTA_API_TOKEN` from `.env` and restart the api
(`docker compose up -d api`). The sync starts only when the token is set.
2. Find the cause before you turn it on again. The usual cause is that the Okta
profile attribute does not match `users.username`. See
`OKTA_SYNC_PROFILE_ATTRIBUTE` in `server/.env.example`.
3. Enable the people who were disabled by mistake (steps above).
4. Set the token again and restart.
If the sync cannot reach Okta, or Okta gives an answer the sync cannot trust, the
sync changes **no** account in that cycle and writes a line to the api log:
`docker compose logs api | grep "Okta sync"`.
## Run the stack on your own PC (T13.8)
Use this to check a build in Docker before you deploy it. It needs Docker Desktop.
Do not use it on the host.
1. Copy `.env.local.example` to `.env` in the repository root. Change the two
`CHANGE` values: the database password and `AUTH_SECRET_KEY`.
2. Run these commands in the repository root:
docker compose -f docker-compose.yml -f docker-compose.local.yml up -d --build
3. Open `http://localhost:8080/api/health`. The answer is `{"ok":true}`.
4. Read the api log: `docker compose logs api`. The log shows each database
migration, then one `Okta sync` line. With no `OKTA_API_TOKEN`, the line says
`DISABLED`. That is correct.
5. To stop it and keep the data, run
`docker compose -f docker-compose.yml -f docker-compose.local.yml stop`.
To stop it and delete the data, replace `stop` with `down -v`.
What this proves: the images build, all migrations run on Postgres, and the app
starts. What it does not prove: sign-in. Okta sends the browser back to the
redirect URI that is set for the Okta app, and that is the production host name.
To rehearse the Okta sync against your real Okta, add `OKTA_API_TOKEN` and
`OKTA_ORG_URL` to `.env` and keep `OKTA_SYNC_DRY_RUN=true`. The local database has
no real users, so every real Okta user shows as a non-match. Use it only to check
that the token works and that the log lines appear.
The override file `docker-compose.local.yml` explains each change that it makes.
## Permissions roles
@@ -382,7 +556,7 @@ which no longer manages accounts.
| Role | May do |
|---|---|
| `admin` | User administration everywhere, app settings, and every project |
| `project_super_user` | Everything `project_admin` may do, **plus user administration on the projects they hold the role on**: create accounts, reset passwords, set permissions, grant project access |
| `project_super_user` | Everything `project_admin` may do, **plus user administration on the projects they hold the role on**: pre-create accounts by username, set permissions, grant project access |
| `project_admin` | On assigned projects: delete work packages, change a **completed** SOP, delete the project |
| `project_user` | Create/edit work packages, author a SOP up to completion; may archive a WP but not delete one |
@@ -399,9 +573,9 @@ Its limits are what make it safe to hand out, and all of them are server-side
* **Scope comes from projects, not the job title.** A super user administers the users
of the projects they hold the role on — via their account role, or via
`ProjectMember.role` for a super user on one job only. No projects, no authority.
* **Account changes need EXCLUSIVE scope.** Resetting a password, disabling, renaming,
changing permissions or deleting are global acts, so they are refused when the
target is also on a project the caller does not administer. The directory shows
* **Account changes need EXCLUSIVE scope.** Disabling, renaming, changing
permissions or deleting are global acts, so they are refused when the target
is also on a project the caller does not administer. The directory shows
those rows read-only with the reason. An app admin has to make the change.
* **No admin or super-user targets, and none granted.** A super user may hand out
`project_admin` / `project_user` only, and may not touch an admin's or another

38
docker-compose.local.yml Normal file
View File

@@ -0,0 +1,38 @@
# Local override (T13.8). Use it only on your own PC, never on the host.
#
# docker compose -f docker-compose.yml -f docker-compose.local.yml up -d --build
#
# What it changes, and why:
# 1. It publishes the web server on http://localhost:8080 (loopback only). On the
# host a reverse proxy reaches the web server over the `proxy` network and no
# port is published.
# 2. It replaces the external `proxy` network with an ordinary bridge that this
# stack owns. A `proxy` network that already exists on a PC may have no gateway
# (internal), and Docker does not publish ports through such a network.
# 3. It makes the web server answer for any host name, so http://localhost:8080
# works. The shipped nginx config answers only for wp.controls.dev, and
# without this every /api request from localhost gets a 404. The change is
# made when the container starts: it removes the stock default.conf, which
# answers to "localhost" first, and marks the app server as the default. The
# shipped config file is not edited.
# 4. It turns the backup service off. Its scripts are checked out with CRLF line
# endings on Windows and cannot start (BL-070). To start it anyway, add
# --profile backup.
#
# Sign-in needs a real Okta redirect URI, so this stack proves the build, the
# database migrations on Postgres, and the Okta sync. It does not prove sign-in.
services:
webserver:
ports:
- "127.0.0.1:8080:80"
command:
- sh
- -c
- rm -f /etc/nginx/conf.d/default.conf && sed -i 's/listen 80;/listen 80 default_server;/' /etc/nginx/conf.d/wp-suite.conf && exec nginx -g 'daemon off;'
backup:
profiles: ["backup"]
networks:
proxy: !override
name: wp_local_proxy
driver: bridge

View File

@@ -27,10 +27,44 @@ services:
POSTGRES_HOST: db
# Optional full-URL override (must be URL-encoded if used).
DATABASE_URL: ${DATABASE_URL:-}
# Signs login session cookies. REQUIRED — compose fails fast if it's unset,
# and the API refuses to start in production without it (see server/auth.py).
# Signs login session cookies, AFTER Okta has confirmed who someone is.
# REQUIRED — compose fails fast if it's unset, and the API refuses to
# start in production without it (see server/auth.py).
AUTH_SECRET_KEY: ${AUTH_SECRET_KEY:?set AUTH_SECRET_KEY in .env (see server/.env.example)}
AUTH_SESSION_HOURS: ${AUTH_SESSION_HOURS:-12}
AUTH_SESSION_HOURS: ${AUTH_SESSION_HOURS:-8}
# Okta OIDC — the only sign-in path (D15/D16). Not marked required the
# way AUTH_SECRET_KEY is: the API starts without these, it just refuses
# every sign-in and says so in the startup log (server/okta_auth.py
# describe()). See server/.env.example for what each one is and how to
# get it from the Okta app integration.
OKTA_ISSUER: ${OKTA_ISSUER:-}
OKTA_CLIENT_ID: ${OKTA_CLIENT_ID:-}
OKTA_CLIENT_SECRET: ${OKTA_CLIENT_SECRET:-}
OKTA_REDIRECT_URI: ${OKTA_REDIRECT_URI:-}
# NOT ${OKTA_IDENTITY_CLAIM:-} — server/okta_auth.py's own default only
# applies when the env var is UNSET, and compose setting it to an empty
# string here is not the same thing as leaving it unset. An empty value
# would make the API look for a claim literally named "", which is
# never present, so EVERY sign-in would 503. Mirror the same default
# here instead, so an operator who leaves .env's copy commented out gets
# the real default, not a broken one.
OKTA_IDENTITY_CLAIM: ${OKTA_IDENTITY_CLAIM:-preferred_username}
# Okta deprovisioning sync (D18, wave 13). OFF until OKTA_API_TOKEN is set; the
# startup log says which. The token is a read-only Okta API token, NOT the OIDC
# client secret above. Empty values here mean "unset" to the code, so the
# ${VAR:-} form is safe for all four (unlike OKTA_IDENTITY_CLAIM above, whose
# code default only applies when the variable is absent).
# Reaching Okta needs outbound https. The `outbound` network the api service
# already joins is an ordinary bridge with a gateway, so no new network is
# needed; the host firewall must allow https to the Okta org.
OKTA_API_TOKEN: ${OKTA_API_TOKEN:-}
OKTA_ORG_URL: ${OKTA_ORG_URL:-}
OKTA_SYNC_CLIENT_ID: ${OKTA_SYNC_CLIENT_ID:-}
OKTA_SYNC_PRIVATE_KEY: ${OKTA_SYNC_PRIVATE_KEY:-}
OKTA_SYNC_DPOP: ${OKTA_SYNC_DPOP:-}
OKTA_SYNC_PROFILE_ATTRIBUTE: ${OKTA_SYNC_PROFILE_ATTRIBUTE:-}
OKTA_SYNC_INTERVAL_SECONDS: ${OKTA_SYNC_INTERVAL_SECONDS:-}
OKTA_SYNC_DRY_RUN: ${OKTA_SYNC_DRY_RUN:-}
# Optional — SMTP password for WP-assignment emails. Email is off by
# default and enabled from the Admin console; this is the only email
# secret and it is never stored in the DB. Leave unset until configured.

Binary file not shown.

Before

Width:  |  Height:  |  Size: 296 KiB

After

Width:  |  Height:  |  Size: 307 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 243 KiB

After

Width:  |  Height:  |  Size: 260 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 340 KiB

After

Width:  |  Height:  |  Size: 169 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 299 KiB

After

Width:  |  Height:  |  Size: 125 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 38 KiB

After

Width:  |  Height:  |  Size: 41 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 32 KiB

After

Width:  |  Height:  |  Size: 32 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 82 KiB

After

Width:  |  Height:  |  Size: 132 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 81 KiB

After

Width:  |  Height:  |  Size: 123 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 23 KiB

After

Width:  |  Height:  |  Size: 32 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 19 KiB

After

Width:  |  Height:  |  Size: 25 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 46 KiB

After

Width:  |  Height:  |  Size: 66 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 43 KiB

After

Width:  |  Height:  |  Size: 34 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 116 KiB

After

Width:  |  Height:  |  Size: 136 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 80 KiB

After

Width:  |  Height:  |  Size: 98 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 128 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 112 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 97 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 78 KiB

View File

@@ -283,7 +283,9 @@ python tests/triage_check.py # A6 - the sidebar answers the stand-up
python tests/qa_gate_check.py # CR-014/D2/D9/D10 - QA gate + capture sink 41 checks
python tests/files_check.py # CR-007/D8 - drawings upload + real offline 36 checks
python tests/sticky_bar_check.py # B6 - save reachable on every wizard step 12 checks
python tests/usage_check.py # D5 - one analytics core, admin report 15 checks
# tests/usage_check.py (D5) removed at T11.6 - it tested the per-browser
# analytics core and admin report, both retired in favour of CR-019's
# server-side Activity & usage card (see docs/waves/decisions-2026-09-17.md).
python tests/creator_dialogs_check.py # S1 creator - 0 natives, errors at fields 20 checks
```
@@ -292,7 +294,7 @@ Wave 8 adds these:
```bash
python tests/kitting_check.py # CR-009/010/012 - statuses, owner, delivery 26 checks
python tests/kitting_notify_check.py # CR-011 - kitting mail, coalesced, gated 17 checks
python tests/materials_check.py # D6 - material list, the CR-005 pattern 17 checks
python tests/materials_check.py # D6 - material list, the CR-005 pattern 20 checks
python tests/mreq_check.py # CR-013 - lightweight request, end to end 19 checks
```
@@ -316,6 +318,17 @@ python tests/critical_reopen_check.py # BL-021 - on-hold mail reaches PM + CM
python tests/console_dialogs_check.py # BL-024 - consoles/launcher: 21 natives -> 0 17 checks
```
Wave 12 (CR-020, bulk user editing) adds these:
```bash
python tests/bulk_users_check.py # CR-020 - bulk routes, guards, audit, CSV; NO browser 61 checks
python tests/bulk_users_ui_check.py # CR-020 - selection, toolbar, CSV, typed delete at 1440/390px
```
`console_dialogs_check.py` gained section 4 (the bulk delete prompt). `tests/cdp.py`
passes `--do-not-de-elevate` on Windows so the probes start from an Administrator
shell (same change as wave 16, T16.4).
**Three probes were re-pointed at `T7.1`.** `sections_check.py` 5b drove the live
cross-frame toggle hand-off, which no longer exists; it now pins the surviving path and
the fact that an UNSAVED toggle correctly does not travel - a behaviour change, recorded

View File

@@ -554,3 +554,302 @@ deliberately deferred.
entry rather than a drive-by.
- **Suggested wave or follow-up:** next housekeeping pass, with the check
widened so it cannot recur.
### BL-026 — No version stamp: "is live current?" cannot be answered from the app
- **Found during:** the 2026-08-21 outage triage (the question that started it)
- **Where:** `Dockerfile` / build, `server/app.py` `/api/health`, admin console
- **What:** the app carries no record of what code it is running. `/api/health`
returns `{"ok": true}` and nothing identifies the deployed commit, so
answering "is the live site on the latest code?" took fingerprinting
(probing for files/routes that only exist after certain merges) in the
middle of an outage. The fix: bake the git SHA into the image at build time
(`ARG GIT_SHA`), return it from `/api/health`
(`{"ok": true, "version": "<sha>"}`), and show it on the admin console's
diagnostics card. Then currency is one glance against `git log -1`.
- **Why not now:** new scope — needs its own item id per the working rules
(D13 is the natural next), and it touches the image build, which deserves a
deploy alongside someone with host access.
- **Suggested wave or follow-up:** next housekeeping pass; ~1 task including a
probe check that /api/health carries a version field.
### BL-027 — Migrations are rehearsed on SQLite only; production is Postgres
- **Found during:** the 2026-08-21 production outage (D6's `material_items`
migration crash-looped the api container)
- **Where:** `DEPLOYMENT.md` (the update/deploy steps), `tests/`
- **What:** the migration chain is verified end-to-end on scratch SQLite, but
production runs Postgres, and the dialects disagree exactly where it hurts:
`server_default=sa.text('1')` on a Boolean passed every SQLite rehearsal and
was refused by Postgres at deploy (DatatypeMismatch), taking the API down
until the table was created by hand. The hotfix (64eac0c) fixed that one
instance and pinned the Boolean-default class in `materials_check`; the
CLASS of dialect drift is still unguarded. Two cheap layers: (1) a runbook
step — render `alembic upgrade --sql` for the postgresql dialect and read it
before restarting (offline, needs no live DB; this render would have shown
`DEFAULT 1` on a boolean); (2) better, a probe that renders every migration
for the postgresql dialect on each run and fails on anything the dialect
rejects or on known-bad patterns.
- **Why not now:** the outage is resolved and the one known instance is fixed
and pinned; the systematic guard is its own small task, not a hotfix rider.
- **Suggested wave or follow-up:** next housekeeping pass, paired with BL-026
(both are "deploys should be boring" work).
### BL-028 — `okta_auth.describe()` is never called
- **Found during:** T10.9 (writing the deploy runbook's live-verification step)
- **Where:** `server/okta_auth.py` (`describe()`), `server/app.py` (no caller anywhere)
- **What:** `describe()` exists specifically to shout `"*** FAKE OKTA PROVIDER
ACTIVE..."` or report missing config at a glance, and both
`server/.env.example` and `server/README.md` tell an operator to "check the
startup log line" for it. Nothing prints it. `app.py` never imports or calls
`describe()` at process start, so that log line does not exist and an operator
following the docs will not find it.
- **Why not now:** a runbook is documentation, not server code; wiring a
startup log call is a real (if small) change to `app.py` and wants its own
diff and its own verification, not a rider on T10.9.
- **Suggested wave or follow-up:** next housekeeping pass. One call
(`logger.info(okta_auth.describe())` near startup) plus updating
`DEPLOY-runbook-2026-09-03.md` Step 4 to check the log line once it exists.
### BL-029 — `users.failed_attempts` / `users.locked_until` are vestigial
- **Found during:** T10.6
- **Where:** `server/models.py` (`User.failed_attempts`, `User.locked_until`)
- **What:** both columns exist to support local-password lockout, which T10.4
removed. They are still reset to `0`/`None` on every Okta sign-in but nothing
increments them anymore — dead columns, not a bug, but schema drift from the
D15 cutover.
- **Why not now:** T10.6 is documentation scope; dropping columns is a migration
and belongs with the rest of the local-password cleanup, not folded into a
docs task.
- **Suggested wave or follow-up:** next housekeeping pass, alongside any other
post-cutover schema tidy-up.
### BL-031 — A raw `rgba()` shadow survives in the creator's stylesheet
- **Found during:** T10.8 (the full suite could finally run through Docker; the
dev sandbox never had a headless browser to run it in before)
- **Where:** `html/wp-creation-styles.css:929`, `.asset-results { ... box-shadow:0
8px 24px rgba(20,30,50,.18); }`
- **What:** `generalinfo_check.py` asserts the whole file carries no raw colour
literal (comments excluded) as part of its CR-003 priority-colour check, and
this one line fails it: 48/49. Confirmed via `git show HEAD` that the literal
is already committed, byte-identical, unrelated to wave 10 — it is the Micron
asset picker's dropdown shadow, which arrived with the `origin/Micron-Assets`
merge (D11, 2026-08-20) and was never swept by `C4`'s token pass (`T9.9`
closed before D11 merged). The fix is a straight swap:
`theme-light.css:217` already declares `--wp-shadow-menu: 0 8px 24px
rgba(20, 30, 50, .18)`, the identical value — this line should read
`box-shadow:var(--wp-shadow-menu);`.
- **Why not now:** unrelated to the Okta wave; fixing a D11-era CSS literal
inside T10.8 (auth verification) is exactly the drive-by `CLAUDE.md` forbids.
- **Suggested wave or follow-up:** next housekeeping pass, with `C4`'s other
leftovers. One-line fix, `generalinfo_check.py` already pins it (49/49 once
fixed).
### BL-030 — `DEPLOY-login-portal.md` is fully stale
- **Found during:** T10.9
- **Where:** `DEPLOY-login-portal.md` (repo root)
- **What:** the original username/password login rollout doc. References
`bcrypt`, `create-admin --password`, `AUTH_SECRET_KEY` as the only secret,
and a login form — none of which describe the app since T10.4/T10.5. Someone
handed this to IT today would be told to do things that no longer work.
- **Why not now:** no task currently owns deploy-doc cleanup as a category;
deleting or archiving a doc is a product/records call (`CLAUDE.md`'s "removed
fields are hidden, not deleted" spirit likely applies to docs too, but that is
worth confirming rather than assuming).
- **Suggested wave or follow-up:** next housekeeping pass — needs Nick on
whether to delete, archive, or rewrite it as historical record.
### BL-060 — A super user is told they can change access the server then refuses
- **Found during:** T12.6 (CR-020 verification, the CSV path)
- **Where:** `server/app.py` `manage_user_problem` (the reason text), `get_user_projects` / `set_user_projects` (the rule)
- **What:** for an account that is also on a project the super user does not
administer, the refusal reason ends "You can still change their access and
role on your own projects." Neither the project-access dialog's routes nor
the CR-020 bulk project route allow that: all of them call
`require_manage_user`, which refuses the account. The bulk route mirrors the
single route on purpose (CR-020: same rules), so the words promise something
neither path does. Either the text or the rule is wrong; which one is a
product call.
- **Why not now:** changing either is out of CR-020's scope (the wave must
not widen what a super user can do), and it needs a decision.
- **Suggested wave or follow-up:** needs Nick: should a super user be able to
add or remove a shared account on their own projects? Then fix the text or
the rule, not both.
### BL-061 — The sync badge covers controls while it shows
- **Found during:** T12.6 (the wave 12 screenshots)
- **Where:** `html/project-data.js` `renderSyncBadge` (fixed bottom-right, `z-index:9998`)
- **What:** for about 2 seconds after each sync the "Everything sent to the
project" badge sits over whatever is in the bottom-right corner: a Delete
button on the User Directory at 1440px, the bulk bar's "Set permissions" at
390px. It is `pointer-events:none`, so clicks pass through, but the control is
hidden while it shows, and on the console pages there is no outbox work to
report at all.
- **Why not now:** `project-data.js` is shared by every page and owned by the
outbox work in wave 14 (T14.1 to T14.3 change this badge's states anyway).
- **Suggested wave or follow-up:** wave 14, alongside T14.1's badge changes:
do not show the badge on pages with nothing to sync, and keep it clear of
page controls.
- **Status:** fixed at T14.3 (2026-10-17). The console pages never show the badge, "Everything sent" shows only
after real work, and the badge moves to a free spot. One dense-screen case is left: BL-072.
### BL-069 - The sync has no cap on one run and no last-admin guard
- **Found during:** T13.3 (D18)
- **Where:** `server/okta_sync.py` `run_sync()`
- **What:** a run disables every account the rules select, however many. If the
identity attribute is partly wrong (it matches some accounts and not others),
one run can disable most of the company, including every admin. The
zero-match guard only stops the case where nothing matches. Disabled accounts
cannot sign in, so re-enabling needs an admin who is still active, or the
`manage_users.py` command line on the host.
- **Why not now:** D18 does not ask for it, and the right limit is a product
call: a count, a share of accounts, a rule that the last active admin never
disables, or all three.
- **Suggested wave or follow-up:** before the first live run, or in T13.6 if
Matt decides. Needs Matt.
## Future build: mobile app and scaling
Logged 2026-10-12 from the meeting with Nick. The answers are in
`docs/waves/decisions-2026-10-12.md` (Q2 to Q14). The path from here to a
mobile version outside the VPN, across projects, is in
`docs/waves/roadmap-mobile-scaling.md`. These are features for a future
build. They have no wave and no `CR-`/`D-` id yet. Give each one an id when a
wave is planned. Items marked "to confirm" have an open question listed in the
decision file ("Still open"). Do not build them until it is answered.
Follow-up answers from Matt on 2026-10-12 are folded into the entries below.
Server work is needed for BL-062 to BL-066 (CLAUDE.md, "Frontend and backend
boundary"). Do not use `localStorage` as the store of record.
### BL-062 - Offline Field View for crews
- **From:** Q2, Q3
- **What:** Field View opens offline for up to **7 days** after the last sign-in
(today: 12 hours). Only crews in Field View work offline. The creator has no
offline mode. When the app opens online again and the account is disabled,
wipe that account's local data.
- **Why not now:** new scope. It needs an id, and it follows the outbox work in
wave 14 (T14.1 to T14.3).
- **Suggested wave or follow-up:** future mobile wave. Check it against the D18
session rules (idle timeout, absolute ceiling): a 7 day offline window and a
session ceiling must agree on what "signed in" means.
### BL-063 - Offline edit conflicts: merge, notify, log
- **From:** Q4
- **What:** When an offline edit meets a newer server version, the app merges
the two, shows a notification to the crew, writes a log entry, and updates the
owner. If both sides changed the same field, **the field value wins**, and the
app keeps a **history of changes**. This replaces the earlier default (keep
both, crew chooses).
- **To confirm:** who "the owner" is, how long the history is kept, and who can
read it. See the decision file, "Still open" item 2.
- **Suggested wave or follow-up:** same wave as BL-062.
### BL-064 - Field photo limits
- **From:** Q5
- **What:** a limit of **5 MB per photo**. This equals the D8 limit that the
server already enforces for drawings (`FILE_MAX_BYTES`), so photos can use the
same upload path and the same D19 download headers.
- **To confirm:** the count per package, and whether the app resizes a photo
before upload (phone photos are often 3 MB to 8 MB). Decision file, "Still
open" item 1.
- **Suggested wave or follow-up:** same wave as BL-062.
### BL-065 - Batch print and merged PDF
- **From:** Q6, Q7, Q8, Q9
- **What:** print many packages in one PDF.
- Limit: **25 packages on phones**. On desktop the user can scale the filter
up to 50 or 100. Open: who sets the larger value (each user, or an admin
setting). Decision file, "Still open" item 5.
- Drawings go **after the form**, in **upload order**, **scaled to fit**.
- SVG drawings are **left out**. A page names each file that was left out.
- Every page shows the **package number, the print date, and page X of Y**.
- **Related:** BL-000d (merge or list attachments on export) asked the same
question for CR-008. This entry answers the layout part of it.
- **Suggested wave or follow-up:** future print wave.
### BL-066 - Keep drawings when a package is deleted
- **From:** Q13
- **What:** deleting a package no longer deletes its drawings. Keep them for
data retention. **The storage quota is freed** when the package is deleted.
Storage will move to cloud storage in a future deployment. This replaces the
earlier default (delete with the package).
- **Today:** drawing bytes live in the Postgres `wp_files` table (CR-007, D8).
The 2 GB per project limit counts them. Kept files must not count toward that
limit, so the count has to change.
- **To confirm:** retention period, who can delete for good, who can recover.
See the decision file, "Still open" item 3.
- **Suggested wave or follow-up:** roadmap Phase 3 (object storage). It affects
D19 (safe download) paths too: recovered files must keep the attachment and
sandbox headers.
### BL-067 - Ready for QA progress weight is 0.85
- **From:** Q12
- **What:** change the progress weight for Ready for QA from 0 to **0.85**.
Today a package falls from 75% to 0% when it reaches Ready for QA.
- **Why not now:** it changes a shipped number on dashboards and roll-ups. Use
its own item id and re-run the roll-up checks.
- **Suggested wave or follow-up:** future wave. Small task.
### BL-068 - One cost-code list, kept in the SOP
- **From:** Q14
- **What:** the creator has 38 cost codes, the SOP has 39, and 13 differ. Keep
**one list, in the SOP**, and make the creator read it.
- **Blocked on:** the correct codes. The **PM** supplies them (decided
2026-10-12). The date is not set. This is a data question and not a code
question.
- **Related:** BL-019 (closed) made a stored code that has left the list stay
as an option. Keep that behavior when the list changes.
- **Suggested wave or follow-up:** future wave, after the codes arrive.
### BL-070 - Shell scripts get CRLF line endings on Windows, and the backup container cannot start
- **Found during:** T13.8 (local Docker run)
- **Where:** `scripts/*.sh`, no `.gitattributes` in the repository
- **What:** Git for Windows checks out `scripts/entrypoint.sh` with CRLF line endings.
The container then fails with `exec /app/entrypoint.sh: no such file or directory`
and restarts in a loop. The files are stored with LF in Git, so the host (Linux) is
not affected. Any PC build is.
- **Why not now:** T13.8 only makes the local run work. The override turns the backup
service off. A `.gitattributes` rule (`*.sh text eol=lf`) is a repository-wide change.
- **Suggested wave or follow-up:** next housekeeping pass. Add `*.sh text eol=lf` and
renormalize.
### BL-071 - smoketest.py cannot sign in against http://localhost
- **Found during:** T13.6 (final verification)
- **Where:** `server/smoketest.py` `seed_session_cookie()`
- **What:** the script puts the session cookie in a Python cookie jar for the domain `localhost`. The jar treats
a host without a dot as `localhost.local`, so it does not send the cookie, and every call after sign-in returns 401.
With `http://127.0.0.1:PORT` the same script passes 27 of 27.
- **Why not now:** it is a test-script quirk and not part of D18. The documented usage lines show `http://localhost:8000`.
- **Suggested wave or follow-up:** next housekeeping pass: use the domain `localhost.local` for a dotless host,
or change the usage lines to `127.0.0.1`.
### BL-072 - The sync badge can cover a control on a very dense screen
- **Found during:** T14.3 (D26, BL-061)
- **Where:** `html/project-data.js` `placeBadge()`; seen on `wp-creation-index.html` at 390px
- **What:** the badge looks for a free spot on the screen, and it covers no control when the screen has room for it.
With the longest state (a change refused by the project, with a long reason) on the creator page at 390px, no free
spot of that size exists. The badge then covers the one control it overlaps least ("Load sample data" at the
time of the check). The person can press Dismiss, or scroll (the badge moves again within 2 seconds).
- **Why not now:** a fixed overlay cannot fix a screen with no gap. The real fix is a layout change: a bar that
takes its own space in the page, or a place for it in the shared header. That is a design decision for all pages,
not part of T14.3.
- **Suggested wave or follow-up:** decide with Nick whether the shared page layout reserves a status line.

View File

@@ -0,0 +1,97 @@
# Context handoff: Work Package Suite
> Update 2026-10-16: waves 11 and 13 (T13.2 to T13.5) are on the release branch `release/waves-11-13-okta-sync`, with T13.1 held back. The branch and wave status tables below describe 2026-10-12. See `docs/waves/wave-13.md` for the current state.
Date: 2026-10-12
Purpose: Give a new chat the facts about waves 11, 12, 13, and 16.
This file is a handoff note. It is not a spec. The spec files stay the source of truth (`IMPLEMENTATION.md`, `docs/waves/*`, `CLAUDE.md`).
It was checked against `git` on 2026-10-12. Earlier chat summaries about this repo are out of date. Use this file.
## 1. Branch state
| Branch | State |
|---|---|
| `main` | At `d42ae0c` (2026-10-06). Contains wave 12 (CR-020, bulk user editing) and wave 16 (D19, D20, D21), both merged by PR. |
| `feat/waves-11-13` | Local and `origin` are the same commit, `da1325c`. It is pushed. It is not merged. It is 13 commits ahead of `main` and 19 behind. |
| `notes/cr019-usage-metrics-d18-deprovisioning` | Holds the same wave 11 work plus the session notes. |
Correction to an earlier statement: the Gitea push is no longer blocked. The branch is on `origin`.
Merge rule from `wave-12.md`: T13.1 (idle timeout) must not reach `main` before T14.1. Do not merge `feat/waves-11-13` into `main` as a whole without a decision from the user. Wave 11 and T13.1 are on the same branch.
Working tree on `main` (2026-10-12) has two untracked files: `WorkPackageSuite_Consolidated_Change_Request_R2.docx` and `docs/waves/decisions-2026-08-25.md`. Do not delete them.
## 2. What is on `feat/waves-11-13`
| Commit | Task | Item |
|---|---|---|
| `75ac930` | Planning docs for CR-019, CR-020, D18 | CR-019, CR-020, D18 |
| `0652fa7` | T11.1 UsageEvent model and migration | CR-019 |
| `850b789` | T11.2 capture usage events | CR-019 |
| `3584695`, `6cde6e3` | T13.1 idle timeout with an absolute ceiling | D18 |
| `8e863ae` | T11.3 aggregation endpoint with filters | CR-019 |
| `2de76d5` | T11.4 usage export (raw and sanitized CSV) | CR-019 |
| `a6c3fbf`, `0b5ab59` | T11.5 admin console "Activity & usage" card, checked at 390px and 1440px | CR-019 |
| `b2a083a` | T11.6 retire the per-browser Usage report | CR-019 |
| `2842ec9` | Session notes for 2026-09-23 | none |
| `4f3a94b` | T11.6 follow-up: fix `tests/autosave_check.py` | CR-019 |
| `da1325c` | T11.7 full verification pass. Wave 11 closed on 2026-09-24. | CR-019 |
Notes:
- `html/wp-usage.js` and `tests/usage_check.py` were deleted in T11.6. The `track()` functions in `wp-creation-app.js` and `work-package-suite-app.js` are now documented no-ops. About 45 call sites stay.
- T11.7 found a real regression that T11.6 caused. `tests/autosave_check.py` still expected the retired tracker to write to `localStorage`. The test was fixed. It now passes 33 of 33. The cause was that T11.6 ran only `tests/baseline_shots.py`, not the full suite. Run the full suite for any frontend task.
## 3. T11.7 verification results (2026-09-24)
- Alembic: upgrade, downgrade, upgrade on SQLite passed. The SQL render for Postgres was clean (this catches SQLite-only DDL, the "BL-027 class" of defect).
- Test scripts: 38 of 39 passed after the autosave fix.
- Two known failures that are not regressions:
- `token_check.py` exits 2. This is a CLI usage detail.
- `generalinfo_check.py` finds an old color-literal gap in `wp-creation-styles.css`.
## 4. Wave status
| Wave | Items | Status |
|---|---|---|
| 10 | Okta OIDC sign-in (D15, D16) | Done. In production. |
| 11 | CR-019 usage and activity metrics | Done on `feat/waves-11-13`. Not on `main`. |
| 12 | CR-020 bulk user editing | Done. Merged to `main` on 2026-10-06 (T12.1 to T12.6). |
| 13 | D18 Okta/AD deprovisioning sync | T13.1 done on `feat/waves-11-13`. T13.2 and later are not started. T13.3 must fail closed. Do not relax that. |
| 14, 15 | Not checked in this handoff | T14.1 must land before T13.1 reaches `main`. Read the wave files before you plan. |
| 16 | D19 safe downloads, D20 one SOP per project, D21 session decode fails closed | Done. Merged to `main` on 2026-10-06. |
Wave 16 decisions (`docs/waves/decisions-2026-10-02.md`): SEC-06 (session revocation) waits for the AWS work. Other SEC findings stay as backlog drafts in `docs/reference/security-review/backlog-drafts.md`.
## 5. Rules that apply here (`CLAUDE.md`)
- Every change traces to an item ID (`CR-`, `F`, `S`, `A`, `B`, `C`, `D`, task `T<wave>.<n>`). New scope gets a new ID.
- One task per PR. Put the task ID and item IDs in the commit message and PR title.
- Do not fix other problems that you see. Log them in `docs/waves/backlog.md`.
- Do not reorder waves. Do not start a wave before the previous wave is merged, unless the task says it is independent.
- Server work is needed for CR-004, CR-018, CR-007, CR-011, CR-014, CR-013, and B4. Do not use `localStorage` for these.
- Do not change: Actual Hours in Closeout (CR-017), localization (A7), uppercase card headers in `console.css` (A5), the logged-override path `confirmEarlyRelease()` (A1), or hidden-not-deleted fields (CR-002, CR-016).
- Token rule: one place defines color, spacing, and type. Do not add raw hex values to page stylesheets.
- Accessibility (C1): use real `<button>`, `<a>`, or input elements. Add `aria-live` for status changes. Keep focus visible. Text contrast is 4.5:1 (3:1 for large text).
- Frontend checks: run `uvicorn server.app:app` on a throwaway SQLite database. Check 390px and 1440px. Capture before and after screenshots. Run the smoke test.
- If a done-when check cannot be run, do not mark the task complete. Say which check failed and why.
## 6. Environment on the user's PC
- Python was installed with `winget`. Tests use the repo `.venv`.
- Browser tests (`tests/cdp.py` and about 40 `*_check.py` scripts) need Edge or Chrome. `cdp.py` starts from an elevated shell (wave 16 note). The Linux sandbox cannot run them.
- See `C:\Users\m.mabrey\GIT\Field Value Driver\sde-meeting-toolkit\docs\context\environment-notes.md` for tool problems (PowerShell `$` removal, long git paths, the 180 second command limit).
## 7. Open items
1. Decide how `feat/waves-11-13` reaches `main`. The T13.1 and T14.1 order is the constraint.
2. Plan the next wave. T13.2 and later need an explicit instruction.
3. Future build list added 2026-10-12: `BL-062` to `BL-068` in `docs/waves/backlog.md` (mobile app, offline Field View, batch print, and related items). Answers are in `docs/waves/decisions-2026-10-12.md` (follow-ups from Matt included). The path to a mobile version outside the VPN is in `docs/waves/roadmap-mobile-scaling.md` (phases 0 to 5; confirmed: all users in the Okta group, multiple customers, company-managed devices; nine open questions in its section 7). These files are uncommitted edits on `main`.
4. Work from the other chat (the SDE Meeting Toolkit) does not touch this repo. See the toolkit `docs/context/` folder.
## 8. Related files
- `IMPLEMENTATION.md` (sections 2 and 4)
- `docs/waves/wave-11.md`, `wave-12.md`, `wave-13.md` (on `feat/waves-11-13`), `wave-16.md`
- `docs/waves/decisions-2026-09-17.md` (CR-019, CR-020, D18), `decisions-2026-10-02.md` (D19, D20, D21)
- `docs/waves/notes-2026-09-23.md` (on `feat/waves-11-13`)
- `docs/waves/backlog.md`

View File

@@ -0,0 +1,75 @@
# Decisions — September 2, 2026
One item, and it retires two decided-and-built items rather than amending them.
---
## D15 — Authentication moves to Okta OIDC; D13 and D14 are retired before deployment
- **Amends:** retires `D13` (LDAPS simple bind against `prime.local`) and `D14` (the CLI
authenticates against the domain). Both were decided and reaffirmed August 21 2026,
built across nine tasks (`T10.1`–`T10.9`), and verified against the live domain. Neither
reached production. Approved by Nick Siegfried.
- **Surface:** `server/auth.py`, `server/app.py` (`login()`), `html/login.html`,
`html/login.js`, `html/auth-guard.js`. `server/ldap_auth.py` does not carry forward —
there is no LDAPS bind in the new design, not even as a fallback.
- **Wave:** 10. The label is reused fresh: the LDAPS work that previously answered to
"wave 10" was built on `feat/ldaps-directory-auth`, which is deleted rather than merged,
and never appeared in `IMPLEMENTATION.md`'s wave table. It carries no claim on the
number.
### What D13/D14 were, for the record
The branch carrying them is deleted, not merged, so their decision record
(`docs/waves/decisions-2026-08-21.md`) no longer exists on any branch. Preserved here so
the reasoning isn't lost along with it:
D13 chose a direct LDAPS simple bind to `ldaps://prime.local:636` as the sign-in
mechanism: no password stored, a successful bind was the authentication, accounts were
provisioned just-in-time from the directory, and roles stayed local. D14 moved the CLI
onto the same bind, removing `create-admin`/`create`. Both were built, tested
(1284/1288 checks, Aug 24), and screenshotted at 390px and 1440px. Neither ever deployed —
`wp.controls.dev` still runs the pre-D13 local-password login as of this decision.
### The decision
Skip LDAPS entirely. Authentication becomes an Okta OIDC authorization-code flow,
replacing local passwords directly — the same full replacement D13 intended, just via
Okta instead of a domain bind. No LDAPS bind exists in this design at any point.
Four things carry forward from D13 unchanged, because they were never LDAPS-specific to
begin with:
1. **No password is stored.** The app never sees a credential of any kind; Okta owns
authentication entirely.
2. **Accounts are provisioned just-in-time.** A first successful Okta sign-in with no
matching local `users` row creates one, at the default role. The matching logic that
was going to key off a directory search instead keys off an OIDC identity claim.
3. **Roles stay local.** Okta, and AD behind it, supplies identity only. This app decides
what an identity may do. Restated because it is the one rule the whole access-control
design depends on — see `BL-029` and the governance discussion that followed it.
4. **Existing accounts keep their roles** on first Okta login, exactly as D13's criterion
4 read for LDAPS.
### Why this, and not LDAPS first and Okta second
`BL-029` (recorded on this branch as `BL-027` before the renumbering forced by main's
independent use of that number) already laid out why OIDC beats the LDAPS bind on three
counts: this app never sees a password, MFA comes from Okta rather than needing to be
built, and the domain-lockout hazard that forced `AUTH_MAX_ATTEMPTS` down to 2 disappears,
because failed attempts land on Okta rather than on a bind this app makes. D13 was decided
before it was known the company already runs an Okta tenant. Once that was confirmed
(security's scoping reply, September 2026), shipping LDAPS first and replacing it with
Okta days later would mean building and deploying the weaker mechanism on purpose. Going
straight to Okta avoids that.
### What still needs answering before this is buildable
Open from the security scoping thread, not yet closed:
- Which OIDC claim carries the AD `sAMAccountName` equivalent (`preferred_username`,
`upn`, or a custom claim) — asked of security, answer pending.
- The exact redirect/callback URI once the hostname situation is reconfirmed
(`https://wp.controls.dev/api/auth/okta/callback` proposed).
- The `Business Technology Group` pilot in Okta, requested for initial testing, with
normal Okta session/MFA behavior rather than a stricter per-app rule.

View File

@@ -0,0 +1,122 @@
# Decisions — 2026-09-03
## D16: Okta admin bootstrap, break-glass posture, and the real scope of T10.4
Raised during hazard review for T10.4 (remove the local password path). D15 settled
*that* local passwords go away and Okta OIDC is the sole replacement; it did not settle
how an admin account gets named once there is no password to set, or what happens if
Okta itself is unreachable. Both are decided here.
### Admin bootstrap
`server/manage_users.py` stays the bootstrap tool — its own docstring already says so
("the `/api/auth/users` endpoint needs an existing admin, so you have to bootstrap one
here") — but it changes from *creating* an account to *promoting* one:
- An operator with shell/DB access on the server runs it against an account that
already signed in through Okta once and was JIT-provisioned by T10.3 (landing at
`project_user`, per that task). The command sets `role = admin` on that existing row
by username.
- It does **not** create a `User` row from scratch and does not touch `password_hash`
(the column is gone after T10.4's migration).
Rejected: minting a brand-new admin row by hand-typed username. `OKTA_IDENTITY_CLAIM`'s
exact format is still unconfirmed by security (open item carried from D15/wave-10.md).
A hand-typed username that doesn't exactly match what Okta actually sends produces a
second, orphaned account instead of promoting the real one. Promoting an
already-JIT-provisioned row sidesteps that entirely — it never has to guess the future
claim value.
Ongoing (non-bootstrap) admin naming needs no new work: `html/users.js` already has a
live role dropdown (`roleSelect`, gated by server-supplied `grantable_roles`) that lets
an existing admin promote any other account, including one JIT-provisioned via Okta.
That path is unrelated to the password removal and keeps working unchanged.
### Break glass
No break-glass path, by design. If Okta is unreachable or misconfigured, the app is
unreachable for everyone, including admins, until Okta is restored.
This matches the precedent already on record for the abandoned LDAPS design (D13/D14):
"LDAPS is the *only* path, no local fallback, no break-glass." Carried forward
deliberately rather than assumed to still apply, given Okta's failure modes differ from
an internal LDAP bind — considered and confirmed, not defaulted into.
Rejected: a toggleable emergency local login gated behind an env flag. It would
reintroduce a stored local credential, exactly what D15 exists to eliminate, for a
scenario (Okta down) judged less likely and less costly than the standing risk of a
forgotten emergency backdoor.
The server-shell CLI (`manage_users.py`, promoting an existing row) is not a formal
break-glass mechanism — it cannot help if no account has ever signed in through Okta —
but it is the same trust tier as "someone with SSH/container access to prod could
already edit the database directly," and it costs no new engineering.
### T10.4 scope correction
Hazard review found real call sites of `hash_password` / `verify_password` /
`password_problem` that the original T10.4 bullet in `wave-10.md` didn't name and that
break the moment those functions are deleted:
- `create_user()` and `admin_reset_password()` in `server/app.py` (the admin console's
"add user" and "reset password" routes).
- `html/users.js`'s "add user" form (`nu-password` field) and "Reset password" button.
- `server/manage_users.py`'s `create`, `create-admin`, and `reset-password` subcommands
(see bootstrap section above for its replacement).
- `tests/browser_check.py` and `tests/launcher_check.py`, which call
`auth.hash_password()` to seed fixture rows.
Also found: `server/smoketest.py` and `server/seed_demo.py` authenticate via
`POST /api/auth/login`, which T10.4 removes, and CLAUDE.md's own verification section
names both scripts as required checks. Fix folded into T10.4 rather than deferred to
T10.7: both scripts switch to minting a session with `auth.create_token()` and setting
the cookie directly, the same technique `tests/browser_check.py` already uses instead
of scripting a login form. No live Okta tenant needed, and T10.4 no longer depends on
T10.7's timing.
`wave-10.md`'s T10.4 bullet is updated to reflect this full scope.
## D17: A dedicated rollback-aware runbook for the Okta cutover deploy
Raised while preparing to close out wave 10: T10.4's migration
(`server/alembic/versions/1d60a608bb51_drop_local_password.py`) drops the
`password_hash` column, and its `downgrade()` re-adds the column with
`server_default=''`. That restores the schema, not the data — the real bcrypt hashes
are destroyed the moment `upgrade()`'s `op.drop_column` commits, and no amount of
`alembic downgrade` brings them back. `DEPLOY-runbook-2026-08-04.md`, the existing
precedent for how a deploy of this repo is handed to IT, has no equivalent case in its
own Rollback section — its migrations are additive or reversible, so nothing there
warns an operator that this one is different.
Three options were on the table: write this runbook now; also document a staged
deploy sequence (ship T10.5's Okta-live-alongside-password state first, verify real
sign-ins, then ship T10.4's column drop as a separate follow-up deploy); or log the
hazard to `backlog.md` and stop there. Decided: write the runbook only. Staged
sequencing is real risk reduction but is a second deploy plan on top of a wave that is
otherwise a single cutover (D15's "full replacement," not a toggle) — worth
proposing on its own if IT wants it, not worth building unasked. Backlog-only was
rejected because the hazard is concrete and dated (this wave, this migration), not a
someday item.
### What the runbook has to do differently from the 2026-08-04 precedent
- Name the five `OKTA_*` environment variables as newly required for this deploy —
the precedent's own "no new environment variables" note does not apply here and
restating it unchanged would be actively wrong.
- Treat the pre-deploy backup (`docker exec wp_db_backup /scripts/db-backup.sh`) as
the only way back once `1d60a608bb51` commits, not as routine due diligence.
- Separate two failure modes that look similar but are not: an Okta app integration
that is misconfigured after a clean deploy (redirect URI, client secret, an
unassigned test account) is fixable in place — fix the config, redeploy the `api`
service, no data at risk, migration already applied and stays applied. Deciding to
abandon Okta and restore local-password code is the severe case — the empty
`password_hash` column means the old code has nothing to check a password against,
so the only way back is the destructive backup restore (`DEPLOY-runbook-2026-08-04.md`
Case C's own procedure, reused here). Conflating these two would send an operator
straight to a destructive restore for a problem that a config fix would have solved.
- Fold in D16's no-break-glass posture: if Okta is down or misconfigured, the app is
down for everyone, including admins, by design — not a defect to roll back from.
Filed as **T10.9** in `wave-10.md` rather than folded into T10.6 (already merged and
verified) or T10.8 (UI/test verification, a different kind of check). New scope found
after the task that raised it closed gets a new ID, per `CLAUDE.md`.

View File

@@ -0,0 +1,355 @@
# Decisions — September 17, 2026
Three items. Like `D11`, `D15`, `D16` and `D17`, these are new scope raised after
R2 closed out (see `docs/reference/completion.md`, T9.7), not a reopening of
anything already decided there.
`CR-019` and `CR-020` get `CR` ids because they are field/product-facing feature
requests — the same kind of thing `CR-001`-`CR-018` were — not internal
engineering calls made mid-build. `D18` gets a `D` id because it is exactly that:
an internal security/architecture call, the same category as `D15` (Okta vs.
LDAPS), not a feature a user asked for.
Requested/raised by Matt Mabrey, 2026-09-17.
---
## CR-019 — Usage and activity metrics (admin console)
- **Area:** Admin Console / Monitoring
- **Priority:** proposed High — the current admin console has no reliable way to
answer "who is using this and how much," which is the same visibility gap the
original UX review found in `B4` (numbers that look authoritative but are not).
- **Source:** Matt Mabrey, 2026-09-17.
### Why this is not already built
`D5`/`T7.10` already shipped a usage-analytics feature — `html/wp-usage.js`, with
a report at `admin.js:666-699` — but it reads `localStorage`, which is scoped to
one browser. The report's own empty state says exactly this: *"No usage recorded
in this browser yet."* It cannot show who across the team is active or what they
use, because each person's activity exists only on their own machine. This is the
same class of defect `B4` named for the pipeline strip — a number that looks
authoritative but is not — just never generalized to this feature. `CR-019` is
therefore new server-side work, not a UI addition on top of what exists.
Two things already in the schema are relevant and reused rather than duplicated:
`User.last_login_at` (one timestamp, no history) and `AuditLog` (append-only,
already records business mutations — WP created, status changed, role changed —
per user, with a timestamp). Neither captures navigation or feature-open events,
which is the actual gap.
### Intent
Give admins a real, server-backed picture of who is using the suite, what parts
of it they use, and how active they are — replacing the per-browser report as
the thing anyone actually looks at.
### Decisions, made 2026-09-17
1. **Retention: indefinite.** No automatic purge of usage-event data. (Separate
from `AuditLog`'s own retention, which this does not change.)
2. **Scope: suite-wide, filterable.** Not per-project by default; the console
provides filters (date range, project, user, tool/page) rather than scoping
the data itself.
3. **Export: raw view shows real identities; export supports sanitization.**
The admin console's own tables and the CSV export both default to real
usernames — this is an internal audit tool, not a public one. But the export
also offers a "sanitize" toggle that replaces the actor with a **stable
pseudonymous id** (a per-user hash, consistent across rows and across
export runs) rather than dropping the identity field outright — so an
external system (Power BI or similar) can still group and trend "by user"
without ever receiving a real name. Flagged here as the recommended
approach rather than the only one Matt confirmed in so many words: if a
fully-anonymous (no stable id at all) export turns out to be what's
actually wanted, that is a one-line change to the same feature, raise it
in the PR rather than treating it as blocking.
4. **The old per-browser report is retired**, not kept alongside the new one.
Once `CR-019` ships, `admin.js`'s existing `usage-admin` panel (reading
`WPUsage.load(...)` per browser) is removed rather than left next to the
real report, where it would show a smaller, misleading number for whoever
happens to have it open. `html/wp-usage.js` and its two call sites
(`html/work-package-suite-app.js`'s wizard dwell-tracking, and the
creator's equivalent) are a separate question — the *recording* code can
stay or go independent of the *admin report* being retired, since dwell
events were never reliably tied to a real identity anyway. Default to
removing both unless a task finds a reason to keep the recorder; log that
reason rather than deciding it here.
### Acceptance criteria
- A new admin-only tab in `admin.html` (same role gate as the User Directory)
shows: active users over a selectable date range (day/week/month), each
user's last-active timestamp, and a breakdown of which tools/pages get
opened and how often.
- Server-side event capture, keyed to the authenticated session (real identity,
not a browser-local guess) — a new table, not an extension of `AuditLog`,
since page-open/navigation events are not business mutations and mixing them
in would make `AuditLog` noisy for its existing, narrower purpose.
- The console's filters cover date range, project, user, and tool/page, and
combine (e.g., "user X, last 30 days, field view only").
- CSV export from the console, in both raw (real usernames) and sanitized
(stable pseudonymous id per user) modes.
- Retention is indefinite; nothing in this item purges data.
- View-only, refresh-on-load. No alerting — matches how the rest of the admin
console works today; if that changes later it is new scope, not a rider on
this item.
- The old per-browser "Usage" report and its admin-console panel are removed
in the same wave, not left running alongside the new one.
- Accessible per `CLAUDE.md`'s standing `C1` rules (this is a new component,
not a legacy one — it ships accessible or it is not done, same as
everything else built since wave 7).
### Frontend/backend boundary
This needs server work, the same way `CR-004`/`CR-018`/`B4` did: a real table,
a capture endpoint, an aggregation endpoint, and an export endpoint. If a task
under this item is being built by writing to `localStorage`, it is rebuilding
the exact defect this item exists to replace — stop and say so, per
`CLAUDE.md`.
### Scheduling
New wave. Wave 10 (Okta) is merged, so this does not wait on anything.
Task breakdown: `docs/waves/wave-11.md`.
---
## CR-020 — Bulk editing of users in the admin console
- **Area:** Admin Console / User Directory
- **Priority:** proposed High — three of the four actions below touch access
control (role, project assignment, active/disabled) and the fourth is a hard
delete; getting the guardrails right matters more than getting it built fast.
- **Source:** Matt Mabrey, 2026-09-17.
### Why this is not already built
Every user-editing action in `html/users.js` today is one row, one action:
a role `<select>` per row, an activate/disable button per row, a
per-user project-membership checklist opened one user at a time, and a
per-row delete. There is no row selection in the User Directory table at all.
Server-side, every corresponding endpoint
(`/api/auth/users/{id}/active`, `/role`, `/project-role`, `/projects`, and
`DELETE /api/auth/users/{id}`) takes exactly one `user_id`. Bulk editing is new
UI (selection) and, for most actions, either a loop over the existing
single-user endpoints or new endpoints that accept a list — the task decides
which, per user count and transaction-safety needs.
**Deletion is already a hard delete today** (`delete_user`, `server/app.py:1121`
— `db.delete(u)`, not a deactivate). Bulk delete inherits that: it is not this
item's job to invent a soft-delete pattern that does not exist for the single
case, but the confirmation step around it has to be sized for the fact that a
bad multi-select now removes more than one account at once, permanently.
### Decisions, made 2026-09-17
1. **All four bulk actions are in scope:** role change, activate/disable,
project assignment (add to / remove from a project, including the
project-role), and delete.
2. **Selection works two ways:** checkboxes (select-all and individual) in the
existing User Directory table, respecting whatever filter is already
applied (role, active/disabled, project) — and a CSV upload, for a one-off
bulk operation against an external list (e.g., an offboarding list that
didn't originate in this app). Both are in scope, not a choice between them.
### Acceptance criteria
- The User Directory table gains row checkboxes and a select-all that respects
the current filter; a bulk-action toolbar appears once at least one row is
selected.
- CSV upload as an alternative to checkbox selection: a list of usernames plus
the action to apply. Validates every row, reports rejected ones by row (bad
username, user not found, actor lacks permission over that user) rather than
silently skipping them — the same validate-and-report pattern `CR-005`
established for list uploads.
- Every existing single-user guardrail carries forward unchanged: an actor
cannot include their own account in a bulk action that would disable, demote,
or delete it; a super user's bulk action is scoped to only the users and
projects `require_see_user`/`require_manage_user` already let them touch
today (a super user cannot use a bulk action to reach a user or project
outside what they manage, even via CSV); `grantable_roles` still gates which
roles an actor may assign in bulk, the same as one at a time.
- Every affected row is written to `AuditLog` individually, exactly as the
single-user endpoints do today (one `role_changed` / `user_deleted` / etc.
row per user) — a bulk action is many audited changes, not one opaque batch
entry, so per-user history stays intact and readable in isolation.
- Confirmation before applying, using the `wp-dialog` kit (`T7.9`), not a
native `confirm()`. The dialog names exactly how many users are affected and,
for delete specifically, lists the affected usernames before committing.
- Partial failure is reported, not hidden: if some rows in a batch fail (scope,
already-deleted, bad CSV row), the action applies to what it can and states
exactly which rows failed and why. It never reports success on a batch that
partly failed.
- Accessible per `C1`: real controls, keyboard-operable selection and bulk-
action toolbar, `aria-live` announcing the result.
### Recommended, not yet confirmed — raise in the PR if this is wrong
- **Bulk delete gets an extra confirmation step beyond naming the count** —
proposed as typing a confirmation phrase (e.g. the word `DELETE`) regardless
of how many rows are selected, since one bad multi-select now removes more
than one account, permanently, with no soft-delete to fall back on. This is
a recommendation, not a confirmed requirement — Matt has not signed off on
the exact mechanism.
- **Project assignment is add/remove, not replace-the-whole-list** — a bulk
"add these users to project X" or "remove these users from project X"
action, rather than a bulk action that overwrites a user's entire project
list. Proposed because add/remove is less likely to clobber project
memberships the actor didn't intend to touch; a replace-the-whole-list
version is a materially different (and riskier) feature if that turns out to
be what's actually wanted.
### Confirmed 2026-10-06 (Matt Mabrey, at the start of wave 12)
Both recommendations above are confirmed as written, and the two details
`wave-12.md` left to the build are decided:
1. **Bulk delete:** the dialog lists the affected usernames and the request is
not sent until the word `DELETE` is typed, whatever the count.
2. **Project assignment is add/remove** to or from one project at a time, with
the per-project permissions role (`ProjectMember.role`) set on add. It never
replaces a user's whole project list.
3. **Changing the table filter clears the selection** (T12.2), and the toolbar
says so, so no row hidden by the filter stays selected.
4. **The CSV holds usernames only** (T12.4). The action and its settings are
chosen in the toolbar and apply to every valid row of the file.
### Frontend/backend boundary
Selection state (which rows are checked) is fine as client-side UI state — it
is not persisted data. Everything the bulk action actually does (role,
active/disabled, project membership, delete) already requires server work
today for the single-user case, and bulk does not change that: no new
localStorage-derived state, no client-side aggregation of what changed.
### Scheduling
New wave. Independent of wave 11 (`CR-019`) — the two do not touch the same
code and can build in either order or in parallel. Task breakdown:
`docs/waves/wave-12.md`.
---
## D18 — Detecting and acting on Okta/AD deprovisioning
- **Raised by:** Matt Mabrey, 2026-09-17, in response to a direct question about
what happens when someone's AD account is removed and Okta subsequently drops
them.
- **Amends:** nothing decided, closes a gap `D15`/`D16` left unaddressed. Those
items designed how identity flows *into* this app (Okta authenticates, this
app JIT-provisions and owns roles); neither addressed what happens when an
identity is withdrawn. This app has never had any deprovisioning signal —
push or pull — since Okta went live.
### What was found
Traced through `server/auth.py` and `server/okta_auth.py`: this app has no
connection back to Okta after initial sign-in. Consequences, confirmed against
the actual code:
1. A local `users` row is never touched by anything Okta-side. `is_active`
stays `True` indefinitely unless an admin manually disables or deletes the
account through the User Directory. There is no flag distinguishing a
terminated employee's account from a current one.
2. `get_current_user` (`server/auth.py:237`) re-checks `is_active` and
`token_version` on **every request** — so a manual disable takes effect
immediately, on the very next request. The gap is not enforcement, it's
detection: nothing tells an admin to go flip that switch.
3. A session already live when someone is deprovisioned keeps working, fully,
for up to `AUTH_SESSION_HOURS` (12 hours today, `server/auth.py:63`),
because validity is checked against this app's own JWT and DB state only,
never against Okta.
4. A NEW session can't be established once Okta drops the account —
`okta_login`/`okta_callback` requires completing Okta's own sign-in, which
Okta itself refuses. The front door closes on its own; the back door (an
already-open session, and the stale local record) does not.
### Decisions, made 2026-09-17
1. **Build a scheduled sync against Okta's Management API**, not an Event Hook.
This app has, since `D15`, only ever reached out to Okta — never received
anything from it — and a polling design keeps that shape rather than
introducing a new inbound, internet-reachable endpoint with its own
signature-verification surface. Traded deliberately: this is
poll-interval-late rather than real-time, which is judged acceptable for an
HR/offboarding-driven event, not a to-the-second requirement.
2. **Revised 2026-09-23, in response to Matt's question about idle time
instead of a flat session length: sessions now slide on activity, with a
hard ceiling underneath.** A flat `AUTH_SESSION_HOURS` forces a re-check
with Okta on a fixed schedule regardless of activity; a pure idle timer
with no ceiling does the opposite — a continuously-active session would
never force a fresh Okta check on its own, which is a worse fit for the
exact threat this item exists to address (someone still clicking around
after being deprovisioned). Decided: **both**.
- `AUTH_IDLE_MINUTES` (new, default **30**): a session with no request
for this long stops being valid. Implemented as a sliding JWT expiry —
the token is reissued with a fresh `exp` on activity, throttled so the
cookie isn't rewritten on literally every request.
- `AUTH_SESSION_HOURS` (existing var, meaning changes to an **absolute
ceiling**): no session survives past this many hours from the original
sign-in, no matter how continuously active it is. Default changing from
12 to a proposed **8** — flagged as a recommendation, not confirmed.
- Both defaults, and the mechanism itself, should be sanity-checked
against the tenant's actual Okta SSO session policy — if Okta's own
session silently outlives either number, re-authentication here is
likely a fast redirect, not a real re-login screen, so these numbers
cost less than they look like they do. Confirm before treating either
as final.
3. **The sync only ever disables an account — it never re-enables one.** A
rehire showing active in Okta again does not automatically restore access;
an admin re-enabling the account is a deliberate act, consistent with
`D16`'s posture that this app never auto-grants access on its own initiative.
4. **Fail closed on the side of INACTION, not disablement.** This is the
opposite failure direction from `D16`'s login-time posture ("if Okta is
unreachable, the app is unreachable for everyone"). Here, an Okta API
error, timeout, empty response, or anything the sync can't confidently
parse must result in **no change to any account** that cycle, plus a
logged failure. A sync job that treats "couldn't reach Okta" as "nobody is
active" is a far worse outcome than a missed cycle — it would lock out the
entire org on an Okta API hiccup. This is the single most important
acceptance criterion in this item.
5. **Every auto-disable is audited individually**, same as every other
account-state change in this app: an `AuditLog` row per user, with an actor
value that's clearly the sync job and not a person (e.g.
`system:okta_sync`), so it reads correctly in the User Directory's history
and is never confused with an admin's own action.
6. **New credential required:** a read-scoped Okta API token (or an Okta
service-app OAuth2 client), separate from the `OKTA_CLIENT_ID`/
`OKTA_CLIENT_SECRET` pair used for sign-in. This needs provisioning by
whoever administers the Okta tenant — the same dependency that gated the
original OIDC rollout (D15's "security scoping reply").
### Recommended, not yet confirmed — raise in the PR if this is wrong
- **Sync interval:** proposed every 15 minutes. Frequent enough that the
detection gap is small, infrequent enough not to hammer Okta's API or need
special rate-limit handling. Not confirmed with IT/security.
- **Where the job runs:** proposed as an in-process background task inside the
existing `api` container (it already has `outbound` network access to reach
Okta, and already holds the Okta client config) rather than a new sidecar
container. The `backup` container (`docker-compose.yml`) is the existing
precedent for a scheduled-interval container in this stack, if isolation
from the `api` process is preferred instead — a reasonable alternative, not
the recommendation.
- **Admin visibility:** at minimum, an auto-disable is a normal, readable
`AuditLog` entry (visible whever admin already reviews audit history, and
naturally covered once `CR-019`'s activity view exists). Whether it should
also trigger an email/notification to admins is a genuine open question —
proposed as a fast-follow rather than blocking this item, since `D10`
already established the pattern for admin-controlled email toggles this
could reuse.
### Frontend/backend boundary
Entirely server-side and infrastructure. No new `localStorage` state, no
frontend surface beyond what already reads `is_active` and `AuditLog` today
(the User Directory, and eventually `CR-019`'s activity view).
### Scheduling
New wave, independent of wave 11 and wave 12 in the sense that nothing here is
blocked by them — but note it touches the same `is_active`/account-state
surface `CR-020`'s bulk actions touch in `server/app.py`. Not a hard
dependency; sequence commits to avoid an avoidable merge conflict, per
`CLAUDE.md`'s "one task per PR" spirit. Task breakdown: `docs/waves/wave-13.md`.

View File

@@ -0,0 +1,84 @@
# Decisions — October 2, 2026
Three items, from the security review of 2026-10-01
(`docs/reference/security-review-2026-10-01.md`). They get `D` ids because they
are internal security calls made mid-build, the same category as `D15` and
`D18`, not features a user asked for.
Decided by Matt Mabrey, 2026-10-02.
| Item | Title | Review finding | Task |
|---|---|---|---|
| `D19` | Uploaded files download safely | SEC-01, SEC-15e (BL-035, BL-036) | T16.2 |
| `D20` | One SOP per project | SEC-02 (BL-048) | T16.3 |
| `D21` | Session decode fails closed; PyJWT upgraded | SEC-07 (BL-052) | T16.1 |
**Schedule:** wave 16. It is **independent of waves 12 to 15**: it touches
`server/` only, and no file in it is changed by a task in those waves except
`server/app.py`, in functions they do not touch (`get_wp_file`, `upsert_sop`,
the SOP baseline readers). Wave 16 may merge before wave 12.
**Out of this round, by decision:** SEC-06 (session revocation) waits for the
AWS work. All other SEC findings stay as backlog drafts in
`docs/reference/security-review/backlog-drafts.md`.
---
## D19 — Uploaded files download safely
- **Problem:** an SVG drawing can carry a script. The server sends it back
`inline` with its own content type, on the app's origin, so the script runs
as whoever opens it (SEC-01). Separately, a file name that is not Latin-1
(for example `Plan é.pdf`) makes the download fail with 500, and CR/LF in a
name reaches the response header (SEC-15e).
- **Decision:** SVG uploads stay **accepted**, but every file that is not a
PDF or a raster image downloads as an **attachment** inside a **sandbox**:
`Content-Disposition: attachment` and
`Content-Security-Policy: sandbox; default-src 'none'`. PDF and raster images
(PNG, JPEG, GIF, WebP, BMP, AVIF) keep opening inline. Every file name goes
out in the RFC 6266 / RFC 5987 form (ASCII fallback plus `filename*`).
- **Why accept SVG instead of refusing it:** no change for the person who
uploads, and no migration for SVGs already stored. The protection is on the
way out, which also covers any SVG already in the database.
- **Must not change:** inline preview of PDF and images (CR-007), the
`Cache-Control` the offline drawing cache relies on, the D8 limits, and the
upload API.
## D20 — One SOP per project
- **Problem:** the rule "changing a completed SOP is a Project Admin action"
checks only the SOP row being posted. A `project_user` can post a NEW SOP id
with `complete: true`. Every reader picks "the latest complete SOP", so that
row becomes the baseline every page loads and the source of PM, CM and QA
mail routing (SEC-02, probe S3).
- **Decision:**
1. A project has one SOP, with the id `sop__<project_id>`. The browser has
always written that id (`pushSOP` in `project-data.js`). A request with no
id gets it. A request that would CREATE a SOP with any other id on a
project is refused with 400.
2. Existing SOP rows with other ids (for example rows `seed_demo.py` made)
stay. They can still be updated under the old rules. Nothing is deleted.
3. While a project has a complete SOP, writing any SOP on that project with
`complete: true`, and changing a complete SOP, needs Project Admin on the
project.
4. The readers prefer the canonical row: `project_sop_team`,
`project_qa_group`, `project_summary` and `GET /api/sops/latest` with
`complete=true&project_id=` read `sop__<project_id>` when it is complete,
and fall back to "latest complete" only when it is not. So a rogue row
made before this fix cannot stay the baseline.
- **Must not change:** a project member drafting the SOP and completing it the
first time (allowed today, allowed after); admin access to project-less
SOPs; the response shape of every SOP route.
## D21 — Session decode fails closed; PyJWT upgraded
- **Problem:** a crafted 1.6 KB cookie makes PyJWT 2.13.0 raise an error that
`decode_token` does not catch, so an unauthenticated request gets a 500 and
a stack trace in the log (SEC-07, probe S12). `pip-audit` lists 13
advisories for 2.13.0.
- **Decision:** pin **PyJWT 2.15.1** (`pip-audit`: no known vulnerabilities on
2026-10-02). `decode_token` treats ANY decode failure, and any cookie longer
than 4096 characters, as "not signed in" (401). It also requires the `exp`
and `sub` claims, which every token this app issues carries.
- **Must not change:** every valid session, the D18 sliding refresh and
ceiling, and the fake Okta test seam.

View File

@@ -0,0 +1,51 @@
# Decisions: October 12, 2026 (meeting with Nick)
Topic: mobile app (offline Field View), batch print, and related scaling questions.
Recorded by Matt Mabrey from the meeting with Nick, 2026-10-12. Follow-up answers from Matt are in the section "Follow-up answers".
This file records the answers. It does not schedule any work. The features that come from these answers are logged in `docs/waves/backlog.md` as `BL-062` to `BL-068` for a future build. The path to a mobile version that works outside the VPN is in `docs/waves/roadmap-mobile-scaling.md`. None of these have a wave or a `CR-` or `D-` id yet. Assign the ids when a wave is planned.
Question numbers (`Q2` to `Q14`) come from the decision table that Matt received. `Q1`, `Q10`, and `Q11` were not in the table. They are not recorded here.
## Answers
| Q | Decision needed | Default that was proposed | Answer |
|---|---|---|---|
| Q2 | Days the app may open offline after the last sign-in (today: 12 hours) | 7 days. Wipe a disabled account's data on the next online open. | **7 days.** The default wipe rule stands. |
| Q3 | Must planners edit in the creator offline, or only crews in Field View? | Field View only | **Only crews in the field.** The creator needs no offline mode. |
| Q4 | An offline edit meets a newer server version. What does the crew see? | Keep both, show differences, crew chooses. Server wins if nobody acts. | **Merge with a notification. Log it. Update the owner.** If the same field changed on both sides, **the field value wins**, and the app keeps a history of changes. This replaces the default. |
| Q5 | Photo limit per photo and per package | Resize to 1280 px, 50 per package | **5 MB per photo.** |
| Q6 | Maximum packages in one batch print | 50, with a message to narrow the filter | **25 on phones.** On desktop the user can scale the filter up to 50 or 100. |
| Q7 | Where drawings go in the PDF, and at what size | After the form, upload order, scaled to fit | **After the form, upload order, scaled to fit.** Same as the default. |
| Q8 | SVG drawings in the merged PDF | Leave out, with a page that names the file | **Leave out, with a page that names the file.** Same as the default. |
| Q9 | What goes on every page | Package no., print date, page X of Y | **Package no., print date, page X of Y.** Same as the default. |
| Q12 | Progress weight for Ready for QA (today 0, so a package drops from 75% to 0%) | 0.85 | **0.85.** Same as the default. |
| Q13 | What happens to a package's drawings when the package is deleted | Delete with the package | **Keep them (data retention). The storage quota is freed.** Storage will move to cloud storage in a future deployment. This replaces the default. |
| Q14 | Which cost-code list is correct (creator has 38, SOP has 39, 13 differ) | One list in the SOP. Needs codes from Accounting or the PM. | **One list in the SOP.** The **PM** supplies the codes. |
## Follow-up answers (Matt, 2026-10-12)
These answer the six questions that were open after the first record.
1. **Q5:** the 5 MB limit is **per photo**. This matches the limit that already exists for drawings (D8, enforced in `server/app.py`: 5 MB a file, 2 GB per project).
2. **Q6:** 25 on phones. Desktop users can scale up (50 or 100).
3. **Q4:** on a conflict in the same field, **the field value wins**. The app keeps a history of changes.
4. **Q13:** the quota is freed. Cloud storage will hold the kept files in a future deployment.
5. **Q14:** the **PM** gives the codes.
6. **Scaling:** Matt asked for a path to a mobile version that scales to multiple projects, outside VPN access, for field agents on phones and tablets on site. That path is in `docs/waves/roadmap-mobile-scaling.md`.
7. **Who uses it:** all end users will eventually be in the Okta group.
8. **Scale:** expect multiple **customers**. The data model needs a customer (organization) level above a project. See Phase 4 of the roadmap.
9. **Devices:** company-managed.
## Still open
1. **Q5:** the count of photos per package, and whether the app resizes a photo before upload. Phone photos are often 3 MB to 8 MB. A 5 MB cap per photo with no resize will reject some normal photos.
2. **Q4:** who "the owner" is (package owner, project owner, or the person who made the server change). Also: how long the history of changes is kept, and who can read it.
3. **Q13:** how long a kept drawing is retained, who can delete it for good, and who can recover it. The quota is freed, so the retained bytes must not count toward the 2 GB project limit. Decide where they are counted instead.
4. **Q14:** the date the PM gives the codes.
5. **Q6:** who sets the larger desktop limit (each user, or an admin setting).
6. The questions in `roadmap-mobile-scaling.md`, section 7 (nine open). The first two (one person on more than one customer, and the isolation model) change the data design. Answer them first.
## Source
Meeting with Nick. Status column in the original table: "Open. Team builds to the default" for every row, as of October 12. The answers above came after that status.

View File

@@ -0,0 +1,115 @@
# Decisions: October 16, 2026
## D22: dry run for the Okta deprovisioning sync
**Asked by:** Matt Mabrey, 2026-10-16. **Extends:** D18 (wave 13). **Task:** T13.7.
**Why:** The sync disables a local account when Okta does not list the person.
If the Okta profile attribute is wrong for some accounts, the first live run can
disable people who have not left (see BL-069). The attribute `profile.login` is
the default for `preferred_username`. It is not confirmed against the tenant, and
the person who deploys has no access to the Okta admin console.
**Decision:** Add the environment variable `OKTA_SYNC_DRY_RUN`.
- Values `1`, `true`, `yes`, `on` (any case) turn it on. Any other value, or no
value, leaves the sync live. It is off by default, so a deploy that does not set
it behaves as before.
- In a dry run the sync does every step of a live run: the fetch, the match, the
zero-match guard and the fail-closed rules. It then changes no account and writes
no audit row.
- It logs one line for each account it would disable, and one summary line with the
number of Okta users, active local accounts, matches, and accounts that would be
disabled. Read them with `docker compose logs api | grep "Okta sync"`.
- The startup line shows the mode.
**Not decided here:** a limit on accounts disabled in one run, and a rule to keep the
last active admin (BL-069). The dry run lets a person see the result before the
first live run. It does not stop a bad live run.
**Rules from D18 that stay:** fail closed, only disable, one audit row for each
change, actor `system:okta_sync`.
## D23: sign in to the Okta Management API as an OAuth service app
**Asked by:** Matt Mabrey, 2026-10-16. **Extends:** D18, T13.2. **Task:** T13.9.
**Why:** The first deploy of the sync ended with `Okta answered HTTP 401`. The
credential that Okta security gave Matt is an API Services app that uses client
authentication `private_key_jwt`. It is a private key (a JWK with the fields `kty`,
`use` and `kid`), not an SSWS API token. The sync sent that value as an SSWS token,
and Okta refused it.
**Decision:** The sync accepts a second credential.
- `OKTA_SYNC_CLIENT_ID` and `OKTA_SYNC_PRIVATE_KEY` (a JWK as JSON, or as base64 of
that JSON). The sync signs a JWT (RS256 or ES256, from the key's `alg`; `kid` goes
in the header; `iss` and `sub` are the client ID; `aud` is `<org>/oauth2/v1/token`;
life 5 minutes; a new `jti` each time) and posts it to `<org>/oauth2/v1/token`
with `grant_type=client_credentials` and `scope=okta.users.read`.
- The access token is used as `Authorization: Bearer` on `/api/v1/users`. It is
requested again at the start of each run. It is not stored.
- `OKTA_API_TOKEN` still works. If both are set, the token wins. A deploy that sets
only a token is unchanged.
- A DPoP token (`token_type` not Bearer) is refused with a clear message.
**Rules from D18 that stay:** fail closed. Any problem with the key, the token
request or the user list raises an error, and the sync changes no account. The key,
the signed JWT and the access token are never logged and never put in an error
message. An error carries the HTTP status and the Okta error code only when that
code is a short lower-case word.
**Not decided here:** how often the key is replaced. A key is registered on the Okta
app and has no expiry that this code checks.
## D24: DPoP for the Okta Management API calls
**Asked by:** Matt Mabrey, 2026-10-16. **Extends:** D23. **Task:** T13.10.
**Why:** The first live token request with the service-app key ended with
`error invalid_dpop_proof`. The Okta app requires DPoP (RFC 9449). With DPoP, every
request carries a signed proof from a key that only the caller holds, so a stolen
access token alone does not work. The choice was to ask the Okta admin to switch DPoP
off, or to build it. Matt chose to build it.
**Decision:**
- `OKTA_SYNC_DPOP` is `auto` (default), `on` or `off`. In auto mode the sync asks for a
plain Bearer token first. If Okta answers `invalid_dpop_proof`, the sync asks again with
DPoP. So one build works whether the Okta app requires DPoP or not.
- Each run makes its own throwaway EC P-256 key. It is held in memory only, never
stored, logged or configured. The public half goes in each proof header.
- Each request gets its own proof (ES256, `typ` dpop+jwt): `htm`, `htu` without the
query, a one-time `jti`, `iat`, the server's latest `nonce`, and on an API call `ath`
(a hash of the access token). The same key is used for the token request and the API
calls. A new client assertion is built for every token attempt.
- A nonce challenge is answered once per request, at the token endpoint and at the API.
The token request is tried at most 4 times.
- A DPoP-bound token is sent as `Authorization: DPoP <token>`. If the setting is `off`
and Okta returns a DPoP-bound token, the sync stops with a clear message.
**Rules from D18 and D23 that stay:** fail closed; the key, the assertions, the proofs and
the access token are never logged or put in an error message; an error carries the HTTP
status and Okta's short error code only. The SSWS token path is unchanged.
**Not verified:** this has been tested only against a fake Okta that follows the RFC. The
first run against the real tenant is the real test.
## D25: the session limit is 8 hours for now
**Decided by:** Matt Mabrey, 2026-10-17. **Closes:** the 2-versus-8 question in `wave-13.md`. **Task:** T13.11.
**The conflict:** the wave 13 exit criteria said `AUTH_SESSION_HOURS` defaults to 2. T13.1's own text and
the T13.1 code say 8. The shipped default on `main` was 12.
**Decision:** The default is **8 hours**. This replaces the exit criterion of 2 hours.
- `AUTH_SESSION_HOURS` defaults to 8 in `server/auth.py`, `docker-compose.yml`, `server/.env.example` and
`DEPLOY-login-portal.md`. A value that is set still wins.
- Until T13.1 lands, 8 hours is one flat limit from the moment of sign-in, with no sliding. Once T13.1 lands, the
same variable is the absolute ceiling and an idle timer sits under it. The default does not change then.
- A person who signs in at the start of a shift is signed out 8 hours later, whatever they were doing. Signing in
again needs Okta to be reachable.
**Open, for wave 14:** how the limit works for a crew that is offline. `wave-14.md` sets that rule.
**Not decided here:** the idle time (T13.1 proposes 30 minutes). It is a proposed value, not a decision.

View File

@@ -0,0 +1,35 @@
# Decisions: October 17, 2026
Status key: **Proposed** means the text is a recommendation. It needs Matt's OK before any build starts.
**Accepted** means Matt approved it and the work may start.
Matt accepted D26 and D27 as written on 2026-10-17 (open questions 1, 2 and 3 in `wave-14.md`: hold the changes of
another person, the offline window ends with the session and then works in read-and-queue mode, and a full device
keeps the change in memory and tells the person). The idle time (question 4) was not decided. It belongs to `T13.1`.
## D26: a sign-in problem never destroys a queued change (Accepted)
**Why:** The outbox (`html/project-data.js`) marks any `4xx` answer except `429` as dead. A `401` means the session ended, and it
gets the same treatment. With a session limit (D25, 8 hours) or an idle timeout (T13.1), a crew that works offline past the limit
comes back online and every queued change is rejected for good. The outbox also hides a full device store, and it sends a queued
change under whoever is signed in, not under the person who made it.
**Proposal:**
- `401` holds the queue. It does not mark anything dead and does not count as a try. The queue sends after a good sign-in.
- `403` stays a permanent refusal, with a clear reason.
- A full device store is reported. The change is never dropped silently.
- Each queued change has an owner. It is sent only when that person is signed in.
**Tasks:** `T14.1`, `T14.3`. **Needs Matt:** open questions 1 and 3 in `wave-14.md`.
## D27: the offline sign-in window follows the server (Accepted)
**Why:** `auth-guard.js` allows the app to open offline for a fixed 12 hours after the last good check, and every page load resets that
time. The server session lasts 8 hours (D25). The two do not agree.
**Proposal:** `/api/auth/me` returns `session_expires_at`. The browser stores it and does not extend it. Offline, the app opens until
that time. After that time, offline, it works in read-and-queue mode and does not redirect. Online, a `401` goes to sign-in and the
queue is kept. The 7 day offline window (`BL-062`) is a later wave.
**Task:** `T14.2`. **Needs Matt:** open question 2 in `wave-14.md`.

View File

@@ -0,0 +1,85 @@
# Session notes — 2026-09-23
Working notes for the `feat/waves-11-13` line (CR-019, CR-020 reserved, D18),
written up before merge. Not a spec document — `wave-11.md`, `wave-13.md` and
`decisions-2026-09-17.md` are the source of truth for scope and acceptance
criteria. This is the "what actually happened building it" record.
## What shipped today
**CR-019 (wave 11) — usage/activity metrics, T11.1 through T11.6 complete:**
- `UsageEvent` table + migration (T11.1), a capture endpoint wired into
`auth-guard.js` so every protected page pings it once per load, plus a
`login` event at Okta sign-in (T11.2).
- `GET /api/usage/summary` (T11.3) — active users by day/week/month,
per-user last-active, per-tool breakdown, filterable by date/project/
user/tool, all combinable.
- `GET /api/usage/export` (T11.4) — raw and sanitized CSV. Sanitized mode
replaces the username with an HMAC-SHA256 pseudonym (keyed with
`auth.SECRET_KEY`), stable per user across rows and across separate
export calls, so an external tool (Power BI etc.) can still group by
user without ever seeing a real name.
- A new "Activity & usage" card in the admin console (T11.5): real filter
controls, the summary tables, both export buttons. Client-side gated
admin-only same as the rest of the console; the API underneath is
independently gated server-side regardless.
- Retired the old per-browser "Usage logs" panel and `wp-usage.js`
entirely (T11.6) — it had no reader left and was never a real data
source for the new report anyway. The scattered `track()` call sites in
the creator and wizard were left in place calling a documented no-op,
rather than deleting ~45 individual call sites for the same effect.
Only **T11.7 (final wave verification)** is left before wave 11 is fully
closed out — everything under it has already been verified per-task, so
this is a consolidation pass, not new work.
**D18 (wave 13) — Okta/AD deprovisioning, T13.1 only:**
- Session lifetime changed from one flat `AUTH_SESSION_HOURS` to a sliding
idle timeout (`AUTH_IDLE_MINUTES`, default 30) capped by a hard ceiling
from original sign-in (`AUTH_SESSION_HOURS`, default 8, meaning changed
from "session length" to "absolute ceiling"). Both defaults are flagged
in `.env.example` and `DEPLOYMENT.md` as proposed, not confirmed against
the tenant's actual Okta SSO policy.
- **T13.2 onward (the actual Okta Management API sync job) is paused** —
explicit call from Matt: no Okta API credential yet, come back to it
later. Not started, not blocked on anything code-side.
**CR-020 (wave 12, bulk user editing):** not started. Reserved, scoped in
`wave-12.md`, no code touched.
## Environment work (not itself a task, but load-bearing)
- Fixed a CRLF/LF mismatch that was making every tracked file look modified
to this session's git client (`core.autocrlf true`, repo-local, no file
content changed).
- This machine had no Python. Installed it via `winget` (`Python.Python.3.12`)
and set up a `.venv` in the repo with `server/requirements.txt` installed,
specifically so `tests/baseline_shots.py` could run locally — this
sandbox has no headless-capable browser and can't download one (network
allowlist), so the 390px/1440px screenshot verification CLAUDE.md asks
for had to run on Matt's own machine instead, using the browser already
installed there (Edge).
- Established a repeatable local verification loop for every task: throwaway
SQLite, fake-Okta sign-in, promote to admin, `seed_demo.py` +
`smoketest.py` (27/27 passing throughout), plus `baseline_shots.py` for
anything touching `html/`.
## Standing constraints, still in effect
- Everything stays local on this branch line. No `git push` at any point
today.
- One task per PR discipline was kept even though all of it landed on one
branch — each commit corresponds to exactly one task ID, in wave order,
each individually verified before the next started.
## Before merging
- Run T11.7 (full wave-11 verification pass) and record it in `wave-11.md`.
- Decide where this branch actually merges to — `feat/waves-11-13` has all
of today's commits already; this notes branch was cut from it so it can
fast-forward back in, or merge as its own PR if the notes should be
reviewed separately from the code.
- T13.2+ and all of wave 12 remain explicitly out of scope until Matt says
otherwise.

View File

@@ -0,0 +1,178 @@
# Roadmap: mobile version, multiple projects, access outside the VPN
Date: 2026-10-12
Status: plan for a future build. It is not a spec. No wave, `CR-`, or `D-` id exists for it yet.
Inputs: `docs/waves/decisions-2026-10-12.md` (Q2 to Q14), `BL-062` to `BL-068` in `docs/waves/backlog.md`, and the code as of `main` (`d42ae0c`).
Goal (from Matt, 2026-10-12): field agents use the app on phones and tablets on site, from outside the VPN, across more than one project.
Scope facts confirmed by Matt on 2026-10-12:
- All end users will be in the Okta group. There are no contractors without an Okta account.
- The product will scale to **multiple customers**, not only more projects for one customer.
- The devices will be **company-managed**.
## 1. Where the product is today
| Area | Fact today | Source |
|---|---|---|
| Mobile shell | A PWA already exists: `manifest.webmanifest` (standalone, "Field View" shortcut) and `sw.js` (caches the app shell and uploaded drawings). | `html/manifest.webmanifest`, `html/sw.js` |
| Offline writes | Writes queue in a sync outbox in `project-data.js`. Reads fall back to a `localStorage` cache. `/api/*` is never cached by the service worker. | `html/sw.js` header |
| Offline drawings | Drawings for the user's assigned packages are prefetched and cached (CR-007, D8). | `html/sw.js`, `html/field.js` |
| Files | The bytes live in the Postgres `wp_files` table. Limit: 5 MB a file, 2 GB per project. | `server/models.py` |
| Sign-in | Okta OIDC. A signed cookie (`HttpOnly`, `SameSite=Lax`, `Secure` over HTTPS). Idle timeout (D18, T13.1) is on `feat/waves-11-13`, not on `main`. | `server/auth.py`, `docs/waves/wave-13.md` |
| Projects | `Project` and `ProjectMember` exist. Access is by project role. There is no organization or customer level above the project. | `server/models.py` |
| Hosting | Docker Compose on an internal host. NGINX serves the site. An external proxy ends TLS. The database and backup containers have no internet route. | `docker-compose.yml`, `nginx/conf.d/wp-suite.conf` |
| Asset picker | Reads the Micron SQL Server catalog through `MICRON_DB_URL`. That database sits on the company network. | `server/assets_db.py` |
| Abuse limits | No rate limiting or login throttling was found in `server/`. CSRF origin checks and security headers (CSP, HSTS) exist. | `server/app.py`, `wp-suite.conf` |
| Security review | The 2026-10-01 review put session revocation (SEC-06) on hold until the AWS work. Wave 16 fixed SEC-01, SEC-02, SEC-07. | `docs/waves/decisions-2026-10-02.md` |
Result: the "mobile app" is mostly built as a PWA. The main work is not a new app. It is (a) finishing offline Field View, (b) making the service safe to put on the internet, and (c) removing the single-host limits.
## 2. Path in phases
Each phase has a gate. Do not start a phase before the gate of the one before it is met, unless this file says the phases are independent. Sizes are rough estimates (S under 1 week, M 1 to 3 weeks, L over 3 weeks). They are not commitments.
### Phase 0: Close the open decisions (S)
- Answer the questions in section 7 and the "Still open" list in `decisions-2026-10-12.md`.
- Assign `CR-`/`D-` ids and write the wave files.
- **Gate:** every item in `BL-062` to `BL-068` is free of "to confirm".
### Phase 1: Finish offline Field View, still inside the VPN (L)
Scope: `BL-062`, `BL-063`, `BL-064`.
1. Land the outbox work (wave 14, T14.1 to T14.3). `wave-12.md` says T13.1 must not reach `main` before T14.1.
2. Set the offline window to 7 days (Q2). Reconcile it with the D18 idle timeout and absolute ceiling. Define what "signed in" means offline. Decide what the 7 day window does when Okta says the account is disabled (wipe on the next online open).
3. Conflict handling (Q4): merge, field value wins on the same field, history of changes, a notification to the crew, a log entry, and an update to the owner.
4. Photos: capture on the device, 5 MB per photo (Q5). Add resize before upload if Matt chooses it. Store photos like drawings (server-side, with D19 download headers).
5. Add a phone and tablet test matrix (real devices): iOS Safari installed to the home screen, Android Chrome, one tablet.
6. Test the weak-link case: no signal, then a slow signal, then a sync with a conflict.
Known platform risks to test on the devices (verify; do not assume):
- iOS may delete site storage after a period of no use unless the PWA is installed to the home screen.
- iOS Safari has no Background Sync. The outbox then sends only while the app is open. A crew member must open the app to push changes.
- A lost device holds up to 7 days of project data. Web storage is not encrypted by the app. See Phase 2.
**Gate:** the crew completes a full shift offline on a test device, reconnects, and the server holds every change. The conflict case works as Q4 says. `tests/mobile_check.py` and the 390px/1440px checks pass.
### Phase 2: Make the service safe to reach from the internet (M to L)
Today the design assumes the firewall. Outside the VPN, the app becomes the perimeter. Do this before any real user connects from the internet.
| Control | Why |
|---|---|
| Rate limiting and login throttling on the API (none today) | Stops guessing and scraping. The toolkit (`sde-meeting-toolkit`) needed the same fix. |
| A WAF or reverse proxy with request limits in front of NGINX | Filters bad requests before they reach the API. |
| Real client IP handling (`X-Forwarded-For` from the trusted proxy only) | Limits and logs must use the real address, not the proxy. |
| Okta policy for the app: MFA, session length, device trust | Okta is the only sign-in path (D15, D16). The policy is the control. Ask the Okta admin. |
| Session revocation (SEC-06) | When a phone is lost, an admin must end that session now. This was put on hold for the AWS work. Bring it forward. |
| A rule for lost devices | Devices are company-managed (decided). Require a device PIN and disk encryption through the device policy. Remote wipe through the device manager. Pair it with session revocation (above), because a wipe cannot reach an offline device. Confirm with IT that the policy covers every phone and tablet that runs the app, and that a lost device is reported quickly. |
| Okta access rule | All end users are in the Okta group (decided). Gate the app on that group. Today the API creates the account on first sign-in; check that a person who is not in the group is refused, and that removal from the group ends access (this is what D18 and wave 13 do). Ask the Okta admin to add MFA and device-trust conditions for the outside path. |
| Cookie flags on every cookie (the OIDC state cookie uses `https_only=False` in `server/app.py`) | Must be `Secure` on the public site. |
| Review the 2026-10-01 findings that stayed in backlog drafts | Re-rank them for an internet-facing service. |
| Outside review (a penetration test) | Required before the customer-IP data is reachable from the internet. |
| Alerting on failed sign-ins and on odd upload sizes | Detect abuse early. |
**Gate:** the controls above are in place and an outside test finds no high findings open.
### Phase 3: Hosting that can leave the office network (L)
The AWS work is already planned (SEC-06 note). Proposed shape. The choice of services is open for Matt and the AWS owner.
- A public edge (load balancer, WAF, TLS) in front of the API and the static site.
- API containers on a managed container service, with a managed Postgres database.
- Files in object storage instead of the database (`BL-066`, Q13). Move the bytes out of `wp_files`. Keep the metadata in Postgres. Kept files from deleted packages go to a retention area with a lifecycle rule. The quota counts only live files.
- Backups and restore tests on the new stack (the current backup container writes to a host folder).
- A private link back to the Micron asset database, or a different design for the asset picker (the catalog is on the company network). Until this exists, the picker falls back to manual entry outside the VPN. Check that fallback works for a user who is online but cannot reach the database (the code treats "unconfigured" as a normal state, but not "unreachable").
- Infrastructure as code, so the environment can be rebuilt.
- Keep the internal deployment working until the cutover.
**Gate:** a full restore test passes, the migration runs on Postgres (render the SQL for the Postgres dialect first, BL-027), and a rollback plan is written and rehearsed.
### Phase 4: Many projects and many customers (L)
Matt confirmed multiple customers. A customer boundary is now part of the plan, not an option. The data model has `Project` and `ProjectMember` but nothing above a project, so this phase changes the base design. Plan for it early. Phase 3 choices (storage layout, database layout) must already allow it.
- Add an organization (customer) level above `Project`. Every project, user role, file, report, export, and search belongs to one organization. A user may belong to more than one organization (for example Prime Controls staff who work for several customers). Decide this rule first (section 7, question 1).
- Isolation: choose the model before any code. Options: one database with an organization id on every row and checks on every query; a separate schema per customer; or a separate database or stack per customer. Matt and the AWS owner decide. The choice sets cost, backup, and the strength of the separation that a customer can be shown.
- Files: one storage prefix per customer, with its own access rule and, if a customer asks, its own encryption key.
- Customer-specific data: the cost-code list, the asset catalog (today Micron only), and the SOP templates must belong to the organization or the project. `BL-068` (one cost-code list in the SOP) must not become one list for all customers.
- Okta: map Okta groups to organizations and projects, so the Okta admin controls who sees which customer.
- Reports and the admin console: super users see only the organizations they are given. Check CR-019 usage reports, the user directory, and the bulk user tools from wave 12 against this rule.
- Onboarding a customer: a runbook with the steps and a checklist.
- Project onboarding: create a project, load its SOP, cost codes (`BL-068`, one list in the SOP, codes from the PM), people, and roles. Use the bulk user tools from wave 12.
- Okta group to project membership mapping, so the Okta admin controls who joins a project.
- Per-project storage and photo quotas (2 GB per project exists today) and per-project usage reports (CR-019 on `feat/waves-11-13`).
- Performance work with a load test: many crews syncing at shift start. Check the outbox flush, the `wp_files` move, and the list endpoints on a large project.
- Data retention rules per project.
**Gate:** two real customers run side by side. A test user in one customer cannot reach any data of the other through any screen, report, export, search, file link, or API call. A test that tries to cross the boundary on purpose passes. The load test meets targets that Matt sets.
### Phase 5: Native wrapper (only if needed) (M)
Wrap the PWA in a native shell (for example Capacitor) only if Phase 1 testing shows a platform limit that the PWA cannot meet: storage eviction, no background sync, camera control, or a company rule for app-store distribution. A wrapper adds app-store review, signing, and update cost. Do not start it by default.
## 3. Order and dependencies
```
Phase 0 -> Phase 1 -> Phase 2 -> Phase 3 -> Phase 4
\_ Phase 5 (decide after Phase 1 device tests)
```
- Phase 2 may start in part while Phase 1 runs (rate limiting, Okta policy review). No crew uses the internet path before Phase 2 is done.
- Phase 3 (storage move) and `BL-066` (retained drawings) are the same work. Do them together.
- Phase 4 needs the Phase 2 and Phase 3 gates. Opening a second project to the internet first would repeat any gap twice.
## 4. Work that this path adds to the backlog
| Id | Item | Phase |
|---|---|---|
| BL-062 to BL-068 | Already logged | 1, 3, 4 |
| New | API rate limiting and login throttling | 2 |
| New | Real client IP handling behind the proxy | 2 |
| New | Session revocation (SEC-06) brought forward | 2 |
| New | Device policy check with IT (PIN, encryption, remote wipe) | 1, 2 |
| New | Okta group gate and MFA/device-trust conditions for the outside path | 2 |
| New | Object storage and lifecycle rules for files, one prefix per customer | 3 |
| New | Asset picker when the Micron database is unreachable | 3 |
| New | Organization (customer) level above `Project`, with the isolation model chosen first | 3, 4 |
| New | Per-customer cost codes, asset catalog, and SOP templates | 4 |
| New | Okta group to organization and project mapping | 4 |
| New | Cross-customer access tests (a test that tries to cross the boundary) | 4 |
| New | Customer onboarding runbook | 4 |
| New | Load test and capacity targets | 4 |
Log these in `docs/waves/backlog.md` when Matt agrees with the plan. This file does not add them, so the backlog stays free of unconfirmed scope.
## 5. Risks
1. **Customer data on lost devices.** Offline data for 7 days on a phone or tablet. Devices are company-managed, which lowers this risk a lot, but only if the device policy (PIN, disk encryption, remote wipe) is real and covers every device. An offline device cannot receive a wipe until it connects. Keep the 7 day window only if IT confirms the policy.
2. **Customer boundary added late.** The data model has no organization level. If Phases 1 to 3 are built without it, every later change touches every table and every query. Choose the isolation model in Phase 0 and design Phase 3 storage around it.
3. **Contract terms.** Customer drawings and asset data may have rules about where they are stored and who can reach them. With several customers, each contract may differ. Check before Phase 3 (cloud storage) and before Phase 2 (internet access).
4. **Okta.** The app has no password of its own. A weak Okta policy for the outside path is a weak app. The Okta admin owns that setting.
5. **Single database host.** The current database is one container with a host-folder backup. Phase 3 fixes this. Until then, do not add projects that need high availability.
6. **Sequence risk.** T13.1 (idle timeout) must wait for T14.1 (outbox). A short idle timeout can end a session while a crew is offline. Settle the rule in Phase 1.
## 6. What does not change
These decisions stay as recorded: Actual Hours stays (CR-017), localization stays (A7), uppercase card headers stay (A5), the logged-override path for predecessors stays (A1), removed fields are hidden and not deleted (CR-002, CR-016), and the token rule for CSS. Mobile work follows the accessibility rules (C1): real buttons, visible focus, `aria-live` for status, hover is not enough on tablets.
## 7. Questions that decide the plan
Answered on 2026-10-12:
- Who are the outside users? **All end users will be in the Okta group.** No separate sign-in design is needed.
- What does "multiple projects" mean? **Multiple customers.** See Phase 4.
- Which devices? **Company-managed.**
Answer these before Phase 0 ends. The first four are new and follow from the answers above.
1. **Can one person work for more than one customer?** For example, a Prime Controls planner on two customers' projects. This sets how the organization level and the Okta groups map to each other.
2. **Which isolation model?** One database with an organization id on every row, a schema per customer, or a database or stack per customer. Do any customers already require a separate stack in their contract?
3. **Who manages the Okta groups?** One group for all users, or one group per customer or project? Does the Okta admin accept that mapping?
4. **What does the device policy enforce today?** PIN, disk encryption, remote wipe, and a time limit for a device to check in. Ask IT.
5. **Connectivity on site.** No signal for days, or weak signal that comes and goes? This sets how long the offline window must really be, and how big the photo queue gets.
6. **AWS.** Is the AWS move approved? Who owns the account? Which region? Can the Micron database be reached from it?
7. **Contract.** Can customer drawings and asset data be stored in cloud storage and reached from the internet? Does each customer have its own terms?
8. **Distribution.** Is an installed PWA enough, or does the company need an app-store app? Company-managed devices can often install a web app from a device policy. Ask IT.
9. **Targets.** How many customers, projects, and users, and how many crews syncing at the same time, in the first year?

233
docs/waves/wave-10.md Normal file
View File

@@ -0,0 +1,233 @@
# Wave 10 — Okta OIDC authentication
Fresh wave 10. The label was previously used by the LDAPS work under `D13`/`D14`, built on
`feat/ldaps-directory-auth`; that branch was deleted rather than merged and never appeared
in `IMPLEMENTATION.md`'s wave table, so it carries no claim on the number. See
`docs/waves/decisions-2026-09-02.md` (`D15`) for why LDAPS was retired before deployment
and Okta chosen instead.
Depends only on `main` as it stands after `D15`. Not sequenced behind any other wave.
## Tasks
- **T10.1 — Add the Okta OIDC client.** Authlib as a dependency. Config via env vars
(`OKTA_ISSUER`, `OKTA_CLIENT_ID`, `OKTA_CLIENT_SECRET`, `OKTA_REDIRECT_URI`), same
pattern `AUTH_SECRET_KEY` already uses in `server/auth.py`.
- **T10.2 — Login-redirect and callback routes.** A route that sends the browser to
Okta's authorize endpoint, and a callback route that exchanges the code for tokens and
validates the ID token. Access gating is Okta's job, not this app's: only accounts
assigned to the app integration in Okta can reach it at all, so there is no app-side
required-group or claim check layered on top. This is a deliberate difference from D13,
which had to gate on a required AD group itself because an LDAPS bind alone could not
distinguish an assigned user from any other domain account.
- **T10.3 — Identity matching and JIT provisioning.** Reuses D13's shape
(`_provision_from_directory`-style matching) keyed off an OIDC claim instead of an LDAP
search result. **Open dependency:** which claim carries the AD `sAMAccountName`
equivalent (`preferred_username`, `upn`, or a custom claim) is asked of security and not
yet answered. Build with a configurable claim name and a documented default, not a
hardcoded one, so the answer can drop in without a code change.
- **T10.4 — Remove the local password path entirely.** Drop `password_hash` (Alembic
migration; plain `op.drop_column`, matching existing precedent for other NOT NULL
columns on `users` — no `batch_alter_table` needed), remove the bcrypt-based
`login()`, remove the username/password form. Real deletion, matching `D15`'s "full
replacement," not a toggle or a fallback. Scope corrected by `D16` after hazard
review turned up more call sites than the original bullet named:
- `create_user()` and `admin_reset_password()` in `server/app.py` (admin console's
"add user" and "reset password" routes) — rework to drop the password field
entirely rather than break.
- `html/users.js`'s "add user" form (`nu-password`) and "Reset password" button —
matching frontend change.
- `server/manage_users.py` — reworked per `D16` from account *creation* to
*promotion*: `create-admin`/`create`/`reset-password` (password-based) are
replaced by a promote-by-username command that operates on a row Okta's JIT
provisioning (T10.3) already created, never a hand-typed new one. This is now
the documented admin-bootstrap path — see `D16`.
- `tests/browser_check.py` and `tests/launcher_check.py` — stop calling
`auth.hash_password()` to seed fixture rows.
- `server/smoketest.py` and `server/seed_demo.py` — currently authenticate via
`POST /api/auth/login`. Switch to minting a session with `auth.create_token()`
directly, the same technique `browser_check.py` already uses, so both scripts
(named explicitly in `CLAUDE.md`'s verification section) keep working without
depending on `T10.7`'s timing.
- **T10.5 — Frontend: login becomes a redirect, not a form.** `login.html`/`login.js`
change to a "Sign in with Okta" flow. Sign-out lands back on the app's own login page.
- **T10.6 — Deployment docs and env var reference.** `DEPLOYMENT.md`,
`server/.env.example`, `server/README.md` describe the Okta config in place of the LDAP
config they never ended up describing (D13 never shipped, so these still describe the
original local-password system today).
Built: all three rewritten — the five `OKTA_*` vars documented the same way
`AUTH_SECRET_KEY` already was, the login-portal/self-service-reset sections replaced
with the Okta flow and the promote-not-create admin bootstrap (D16), the smoke-test
walkthrough updated for `WP_SMOKE_USER`-only / must-share-`AUTH_SECRET_KEY`-and-DB
(T10.4's `smoketest.py` rewrite). Also `docker-compose.yml`, not originally named in
this bullet: its `api` service sets `environment:` as an explicit allowlist, not
`env_file`, so the documented vars would silently never reach the container without
adding them there too — found and fixed in the same commit rather than shipping docs
for a config path that doesn't work. `OKTA_IDENTITY_CLAIM` mirrors
`okta_auth.py`'s own default (`preferred_username`) in the compose file rather than
defaulting to an empty string, which would 503 every sign-in.
Logged, not fixed here (out of scope): `users.failed_attempts`/`locked_until` are
vestigial (still reset on every Okta sign-in, nothing increments them since local
`login()` is gone); `server/README.md`'s own "Production — Docker Compose" section
is a self-contained alternate quickstart that already diverged from the real root
`docker-compose.yml` before this task and still does.
- **T10.7 — Test coverage without a live Okta dependency.** A fake-OIDC-provider test
seam, mirroring `ldap_fake.py`, so the suite runs with no live Okta tenant reachable.
Built: `server/okta_fake.py` (env-driven, `WP_OKTA_FAKE_DIRECTORY`, production-refusing
the same way `ldap_fake.py` does), dispatched from `okta_auth._build_oauth()` before
the real Authlib client is considered. Only the two Authlib calls that touch the
network — `authorize_redirect` / `authorize_access_token` — are faked; `app.py`'s
`okta_login()`/`okta_callback()` (the `?next=` guard, the disabled-account check, JIT
provisioning, the identity-claim lookup) run unmodified against the fake, same
boundary the LDAP predecessor drew around the anonymous-bind guard. Two fake-only
routes (`/_fake_provider`, `/_fake_provider/consent`) stand in for Okta's own sign-in
screen and are registered in `app.py` only when the fake is active at import time —
in production they do not exist, not merely refuse. `tests/browser_check.py`'s
`start_server()` now takes an optional `extra_env` and sets
`WP_OKTA_FAKE_DIRECTORY` unconditionally (same reasoning `ldap_fake`'s equivalent
used: almost nothing signs in, but the one check that does should not fail
mysteriously). `tests/url_state_check.py` scenario 2 is un-skipped and drives the
real round trip — login.html's button, the fake picker page, the fake consent
redirect, `okta_callback()` — proving `?next=` survives it, same tightened
"actually left login.html" assertion the LDAP predecessor's own bug fix used.
`tests/okta_auth_check.py` is new: the production guard, single-use/replay on the
authorization code, an unsolicited callback hit, a tampered state, a denied consent,
an unknown identity, a disabled account, JIT provisioning, an existing admin
surviving unchanged, same-site vs. off-site `?next=`, and `OKTA_IDENTITY_CLAIM`
genuinely working under a non-default claim name — 22/22.
The dev sandbox this was built in has no headless browser and no way to install
one, so `tests/url_state_check.py` and `tests/browser_check.py` (both need
`tests/cdp.py`'s real headless Chromium) could not be run there — only
`okta_auth_check.py`'s HTTP-level coverage of the same mechanism. Run for real
afterward on a machine with Docker, via a separate general-purpose tool
(`headless-py-test-runner`, kept out of this repo — it is not Work Package Suite
specific): `url_state_check.py` 26/26, including scenario 2's real click-through of
the fake-Okta round trip, and `browser_check.py` 71/71. Gap closed.
**Validated 2026-09-03:** `tests/okta_auth_check.py` 22/22 (no browser needed) ·
`tests/url_state_check.py` 26/26 · `tests/browser_check.py` 71/71 — all three run
clean, the last two against real headless Chromium via Docker.
- **T10.8 — Verification.** 390px and 1440px, full suite, done-when checks per task,
matching the rigor D13 was held to.
Done-when checks per task, verified against the actual code rather than
re-reading this file's own claims: T10.1 (Authlib pinned, the four env vars,
`is_configured()`/`describe()`), T10.2 (the login/callback routes, no
app-side group or claim gate layered on Okta's own), T10.3 (identity-claim
matching, JIT at the lowest role, local deprovisioning still enforced after
Okta approves), T10.4 (zero remaining references to `bcrypt` /
`password_hash` / `hash_password` / `verify_password` anywhere in `.py` or
`.js`, `manage_users.py promote`, `smoketest.py` / `seed_demo.py` /
`browser_check.py` / `launcher_check.py` all minting via `create_token()`),
T10.5 (`login.html` is one Okta link, no password field). All matched what
this file already claimed — no drift found.
Full suite, run through the Docker test runner (all 41 files in `tests/`,
bare invocation): 39 passed clean. `tests/token_check.py` "failed" at exit 2,
but that is a harness mismatch, not a check failure — it is a two-step
snapshot/diff tool (`--out` to capture, `--compare A B` to diff) and prints
usage + exits 2 when run with no arguments, which is what a bare full-suite
pass does to every file. `tests/generalinfo_check.py` scored 48/49 — the one
failure is a raw `rgba()` shadow literal in `wp-creation-styles.css`,
confirmed via `git show HEAD` to already be committed and unrelated to this
wave (it is the Micron asset picker's dropdown shadow from the `D11` merge,
2026-08-20, predating this wave by two weeks). Logged as `BL-031` rather than
fixed here — an unrelated CSS token-rule violation is not this wave's to fix.
`tests/okta_auth_check.py` re-run fresh (no browser needed): 22/22.
390px and 1440px: `tests/baseline_shots.py` captured all fourteen shots
(login, launcher, sop, creator, admin, users, field × two widths) into
`docs/reference/baseline/`. `login-390.png`/`login-1440.png` and
`users-390.png`/`users-1440.png` visually confirmed: the login page is a
single "Sign in with Okta" button with no username/password form at either
width, and the User Directory's table and "Add a user" form both carry no
password column and no reset-password action anywhere, at either width.
Wave 10 is complete. The three items in "Still open" below are external
(security team / Okta admin), not blocked on any task in this wave.
- **T10.10 — Audit `manage_users.py promote`.** Raised in review after T10.8:
`cmd_promote()` changed a user's role with no audit trail at all, unlike the
identical role change from the web Admin Console (`app.py`'s
`set_user_role()` → `log_event()`, action `"role_changed"`). Not a new
privilege — anyone with Portainer/container-exec access to `wp_api` already
has shell access to the database directly, same trust tier D16 already named
for this command — but there was no record of who ran it or what changed.
Built: `cmd_promote()` now writes an `AuditLog` row with the same
`action`/`detail` shape `set_user_role()` uses (`{"from": old_role, "to":
role}`), tagged `"via": "cli"` (mirrors JIT provisioning's own `"via":
"okta_jit"` tag) and `actor="cli:manage_users"` — a container shell exec
carries no signed-in identity to attribute the change to a real person, so
it names the tool rather than guessing one. Verified end to end against a
scratch SQLite database: the audit row lands with the exact expected shape,
the role change persists, and the existing "no such user" refusal still
exits 1 with no partial write.
- **T10.9 — Rollback-aware deploy runbook.** Raised after hazard review found
`DEPLOY-runbook-2026-08-04.md`'s Rollback section has no case for a migration whose
`downgrade()` cannot restore the data it drops — see `D17`. `T10.4`'s
`1d60a608bb51_drop_local_password` is exactly that: the schema comes back, the
bcrypt hashes do not.
Built: `DEPLOY-runbook-2026-09-03.md`, following the 2026-08-04 runbook's structure
(fill-in table, numbered deploy steps, case-by-case Rollback section, Notes). Names
the five `OKTA_*` vars as newly required (the precedent's "no new environment
variables" note does not carry over), treats the pre-deploy backup as the only way
back once the migration commits, and splits Rollback into the fixable case (Okta app
integration misconfigured — fix and redeploy `api`, no data at risk, migration stays
applied) versus the severe case (abandoning Okta for local-password code — only the
destructive backup restore gets there, reusing the 2026-08-04 runbook's own Case C
procedure). D16's no-break-glass posture is stated plainly rather than left implicit.
Logged, not fixed here (out of scope): `okta_auth.describe()`'s startup log line
(referenced by `DEPLOYMENT.md`/`server/README.md`) has no caller anywhere in
`server/app.py` — nothing actually prints it at process start. The runbook's Step 4
therefore verifies via a live Okta sign-in rather than a log line, and this gap is
flagged in `docs/waves/backlog.md` as a candidate fix (wiring `describe()` into
startup) since it directly bears on deploy verifiability. `DEPLOY-login-portal.md`
is now fully stale (bcrypt, `create-admin --password`, none of which still exist) —
not touched, no task claims it.
## Still open
- The `Business Technology Group` pilot assignment in Okta. Originally six names
(Carlee Swihart, Drew Hilliard, Matt Mabrey, Nick Siegfried, Rachel Schreiber, Terry
Sajan); Cody and Cameron added 2026-09-09. Adrian added only Matt at first,
deliberately, pending the live sign-in confirmation below — awaiting his response to
add the rest of the group now that it has.
Closed since first written: admin bootstrap and break-glass posture, previously open
questions, decided in `D16` (2026-09-03) and folded into `T10.4` above.
**Closed 2026-09-09, live in production:** the redirect/callback URI
(`https://wp.controls.dev/api/auth/okta/callback`) is confirmed working, and so is the
OIDC claim mapping (`T10.3`) — `preferred_username` (the code's documented default,
never actually confirmed by name in Request 50649's thread) is correct, no
`OKTA_IDENTITY_CLAIM` override needed. Both settled by an actual live sign-in against
the real Okta tenant after `main` was merged (`cc64c88`) and deployed: Matt signed in
as himself, matched his existing pre-Okta admin account by `find_user()` rather than
JIT-provisioning a duplicate (the account already existed — this app has ~40 real
users, not the seeded test fixture), landed on `index.html` signed in, admin role and
project access untouched. One real deploy-time snag on the way, worth recording since
it's exactly the Case B scenario `DEPLOY-runbook-2026-09-03.md` anticipated: the first
redeploy left `OKTA_CLIENT_ID`/`OKTA_CLIENT_SECRET`/`OKTA_ISSUER` as empty rows in
Portainer (env var names added, values never filled in) — caught via
`is_configured()`'s all-four-required check failing closed (the 503 "Sign-in is
temporarily unavailable"), not silently. A second snag after filling those in:
`OKTA_ISSUER` was pasted without its `https://` scheme, which surfaced as
`httpx.UnsupportedProtocol` from Authlib's OIDC discovery fetch rather than anything
the app's own code raises deliberately — the exact case the runbook's Notes flagged as
having no startup-time confirmation (`okta_auth.describe()` still has no caller,
`BL-028`). Both fixed by correcting the env var values in Portainer and redeploying;
neither needed the backup or the database.

280
docs/waves/wave-11.md Normal file
View File

@@ -0,0 +1,280 @@
# Wave 11 — Usage and activity metrics
**Items:** `CR-019`
**Depends on:** wave 10 merged (it is; this wave does not wait on anything else)
**Decision record:** `docs/waves/decisions-2026-09-17.md`
Seven tasks, one concern each, in build order. Do not start a task whose
dependency is not merged. `CR-020` (bulk user editing) is reserved but not
scoped — it does not belong in this wave.
---
### T11.1 — CR-019: `usage_events` table + migration
- **Items:** `CR-019`
- **Depends on:** nothing (first task)
- **Blocks:** T11.2
- **Surface:** `server/`
- **Files:** `server/models.py`, `server/alembic/versions/`
**Do:** Add a `UsageEvent` model — append-only, same spirit as `AuditLog` but for
navigation/feature-open events rather than business mutations. Suggested shape:
`id`, `at` (indexed), `user_id` (or username — match whatever `AuditLog.actor`
does today for consistency), `project_id` (nullable — not every event is
project-scoped, e.g. opening the admin console), `tool` (e.g. `creator`,
`wizard`, `field_view`, `dashboard`, `admin`, `directory`), `event` (e.g.
`page_open`, `login`), `detail` (JSON, optional). Write the migration. Do not
touch `AuditLog` — this is a new table, not an extension of it (see the
decision record's reasoning).
**Do not:** fold this into `AuditLog`. They serve different questions and mixing
them makes the existing audit trail noisier for its existing readers.
**Done when:**
- [ ] `UsageEvent` exists with an indexed `at` column (this table will be scanned
by date range constantly)
- [ ] migration applies cleanly against both SQLite (dev) and Postgres (prod) —
render `alembic upgrade --sql` for postgresql and read it before calling
this done, per the class of defect `BL-027` logged
- [ ] no change to `AuditLog`'s shape or behavior
---
### T11.2 — CR-019: capture the events
- **Items:** `CR-019`
- **Depends on:** T11.1
- **Blocks:** T11.3
- **Surface:** `server/` + `html/`
- **Files:** `server/app.py` (new endpoint), `html/auth-guard.js`
**Problem:** Six pages need this and none should implement it separately — that
is exactly how `S4`'s "no global nav on two pages" and the four parallel token
systems (`S5`) happened. `auth-guard.js` is already loaded first, in the `<head>`,
on all six protected pages (`index.html`, `field.html`, `users.html`,
`wp-creation-index.html`, `work-package-suite.html`, `admin.html`) and already
knows the verified user once the `wp-auth-ready` event fires. That is the one
place this belongs.
**Do:** Add a small `POST /api/usage/ping`-style endpoint that writes one
`UsageEvent` row per call, keyed to the session (server trusts the session, not
anything the client claims about identity). Call it once from `auth-guard.js`
after `wp-auth-ready`, tagging `tool` from the page's own path. Also write a
`login` event at the point a session is actually established (reuse whatever
`okta_callback` already does at sign-in — do not add a second source of truth
for "did this person log in").
**Do not:** build a per-page capture call. If a page needs this and
`auth-guard.js` does not cover it, fix `auth-guard.js`, not the page.
**Done when:**
- [ ] one `page_open` event is recorded for a real sign-in on each of the six
pages, verified per page
- [ ] exactly one `login` event per Okta sign-in, not one per page load after
it
- [ ] the endpoint rejects a request with no valid session (this is server-
enforced identity, not client-reported)
- [ ] no page other than `auth-guard.js` calls this endpoint directly
---
### T11.3 — CR-019: aggregation endpoint with filters
- **Items:** `CR-019`
- **Depends on:** T11.2
- **Blocks:** T11.4, T11.5
- **Surface:** `server/`
- **Files:** `server/app.py`
**Do:** Build the read side: active-user counts by day/week/month, per-user
last-active timestamp (derived from `UsageEvent`, not `User.last_login_at`,
which only ever holds one value), and a per-tool usage breakdown. Accept query
filters: date range, project, user, tool — combinable, per the decision record.
This is server aggregation, the same principle `B4` established for the
pipeline strip: the browser asks for a number, the server computes it from real
rows, nothing is derived client-side from a partial cache.
**Done when:**
- [ ] active-user counts are correct against a seeded fixture with known dates
- [ ] filters combine correctly (verified: user + date range + tool together
narrows correctly, not just each alone)
- [ ] a project filter that matches nothing returns an empty result, not an
error or the unfiltered total
---
### T11.4 — CR-019: export, raw and sanitized
- **Items:** `CR-019`
- **Depends on:** T11.3
- **Blocks:** T11.5
- **Surface:** `server/`
- **Files:** `server/app.py`
**Do:** A CSV export endpoint over the same filtered query T11.3 exposes.
Two modes: raw (real usernames, the console's default) and sanitized. Sanitized
mode replaces the actor field with a stable pseudonymous id — a per-user hash,
consistent across rows in the same export and across separate export runs —
so an external system (Power BI or similar) can still group and trend "by
user" without ever receiving a real name. Do not simply drop the identity
column; that breaks per-user grouping downstream, which defeats the point of
an activity export.
**Done when:**
- [ ] raw export contains real usernames
- [ ] sanitized export never contains a real username or email anywhere in the
file, including in a `detail` blob if one is included
- [ ] the same real user maps to the same pseudonymous id within one export AND
across two separate export runs (a hash of something stable, not a
per-request random id)
- [ ] both modes otherwise contain identical rows for the same filter
---
### T11.5 — CR-019: admin console Activity tab
- **Items:** `CR-019`
- **Depends on:** T11.3, T11.4
- **Blocks:** T11.7
- **Surface:** `html/`
- **Files:** `html/admin.html`, `html/admin.js`
**Do:** New tab, same role gate as the User Directory. Filters (date range,
project, user, tool) driving the tables from T11.3; export buttons (raw and
sanitized) calling T11.4. Build accessible from the start per `C1` — this is a
new component, not a legacy one carrying an old defect forward: real
`<button>`/`<select>` controls, keyboard-reachable, `aria-live` on any
count that updates without a page reload, focus visible throughout.
**Done when:**
- [x] the tab is reachable only by an admin (the card lives inside admin.html,
already gated client-side by gateByRole(); the API underneath it is
independently gated server-side by require_user_manager regardless)
- [x] every filter is a real form control, keyboard-operable (date/select/text
inputs and a `<button>`, no click-div)
- [x] both export buttons produce the files T11.4 defines (verified against
the live endpoint in T11.4's own checks, and present/wired here)
- [x] works at 390px and 1440px — verified 2026-09-23 via
`tests/baseline_shots.py --pages admin` run locally on Windows (this
sandbox has no headless browser available; the script was run on the
user's machine instead, after installing Python via winget since it
wasn't present). Screenshots in `docs/reference/baseline/admin-390.png`
/ `admin-1440.png`. No JS errors, no horizontal overflow at either
width; the card rendered with real seeded data (events, by-tool,
per-user-last-active tables) confirming the filters and summary read
correctly, not just that the markup exists.
---
### T11.6 — CR-019: retire the per-browser Usage report
- **Items:** `CR-019`
- **Depends on:** T11.5
- **Blocks:** T11.7
- **Surface:** `html/`
- **Files:** `html/admin.js` (the `usage-admin` panel, `admin.js:666-699`),
`html/wp-usage.js` and its two call sites
**Do:** Remove the old per-browser `usage-admin` panel from `admin.js` now that
the real one exists, per the 2026-09-17 decision. Decide what happens to
`wp-usage.js`'s recording calls (wizard dwell-tracking, the creator's
equivalent): they were never reliably tied to a real identity, so they are not
a data source the new report can adopt. Default to removing the recorder too
unless it is still doing something useful on its own (re-read what it actually
records before deciding — do not assume from this file alone).
**Do not:** leave the old panel in place "just in case." Two activity reports
showing two different numbers is worse than one.
**Decision (2026-09-23):** `wp-usage.js` is removed, not kept — it had no
reader left once the admin panel above it was removed (the "download the
full event log" button lived only in that panel), and per the original
decision record it was never reliably tied to a real identity, so it was
never a candidate source for the new report either. The file itself and its
three `<script>` includes (`admin.html`, `wp-creation-index.html`,
`work-package-suite.html`) are gone. Its two call sites
(`wp-creation-app.js`, `work-package-suite-app.js`) keep a local `track()`
function as a documented no-op rather than having each of their ~45
individual `track('event', …)` call sites deleted one at a time — that
would be a far larger, riskier diff for the same outcome (no more data is
recorded either way), and it keeps each call site as a marker of what was
worth recording if usage analytics are ever rebuilt server-side. The
dwell-timer plumbing that only ever fed `track()` (`work-package-suite-app.js`'s
`_stepEnter`/`trackStepDwell`) was left in place for the same reason — it is
inert now, not broken, and touching it buys nothing.
Also removed: `tests/usage_check.py` (tested exactly the retired feature —
D5/T7.10's per-browser analytics core and admin report) and its line in
`docs/reference/file-map.md`, replaced with a note pointing at this decision.
**Done when:**
- [x] the old `usage-admin` panel and its markup are gone from `admin.html`/
`admin.js`
- [x] a decision on `wp-usage.js` itself is recorded (removed, or kept with a
stated reason) — not left ambiguous — see above
- [x] nothing else in the app references the removed code; grep confirms
(only remaining hits are this file, the 2026-09-17 decision record, and
the two explanatory code comments left at the retired call sites — all
prose, not live references)
---
### T11.7 — CR-019: verification
- **Items:** `CR-019`
- **Depends on:** T11.6
- **Blocks:** nothing
- **Surface:** `html/` + `server/`
- **Files:** as touched above
**Do:** Full verification per `CLAUDE.md`: run the app locally, exercise the
new tab at 390px and 1440px, before/after screenshots, run the existing smoke
test and `seed_demo.py`, run the full suite.
**Done when:**
- [x] all `CR-019` acceptance criteria in `decisions-2026-09-17.md` are met or
a failure is stated with a reason — all met
- [x] screenshots committed — `admin-390.png`/`admin-1440.png` (and
`creator`/`sop` at both widths, touched by T11.6's script-tag removal)
- [x] smoke test and `seed_demo.py` both still pass — 27/27, verified
2026-09-24 against the exact branch state about to be considered
deployable
- [x] full test suite passes — verified 2026-09-24: ran all 39
`tests/*_check.py` scripts plus the `usage_events` migration
round-trip. Result: 38/39 exit 0.
- `token_check.py` exits 2 with no arguments by design (needs `--out`
or `--compare`) — a CLI-invocation detail, not a test failure;
already confirmed non-regression in wave 10.
- `generalinfo_check.py` has one pre-existing failure (a raw colour
literal in `html/wp-creation-styles.css`, a file no wave 11/13 task
touched) — already diagnosed as pre-existing in wave 10.
- `autosave_check.py` **did** regress from T11.6 (it asserted the
retired analytics tracker still wrote to localStorage) — found by
this run, fixed same day (commit `4f3a94b`), now 33/33.
- Migration (T11.1): SQLite upgrade → downgrade → upgrade round-trip
clean; `alembic upgrade ... --sql` against the `postgresql` dialect
renders valid DDL (`TIMESTAMP WITH TIME ZONE`, `JSON`, no
SQLite-only syntax) — no `BL-027`-class defect.
---
## Wave 11 exit criteria
- [x] real, server-side activity data exists per user, indefinitely retained
- [x] the admin console shows it, filterable by date/project/user/tool
- [x] export works in both raw and sanitized form
- [x] the old per-browser report is gone, not duplicated
- [x] `CR-019` fully accounted for, no open acceptance criteria
Wave 11 is closed out as of 2026-09-24. `CR-020` (wave 12) remains reserved
and unstarted. `D18`/wave 13 (`T13.2` onward) remains paused pending an Okta
API credential, per standing instruction — `T13.1`'s session changes were
included in this same verification pass and did not regress anything above.

263
docs/waves/wave-12.md Normal file
View File

@@ -0,0 +1,263 @@
# Wave 12 — Bulk editing of users
**Items:** `CR-020`
**Depends on:** wave 10 merged (it is). Independent of wave 11 (`CR-019`) — no
shared files, may build in either order or in parallel.
**Decision record:** `docs/waves/decisions-2026-09-17.md` (open details
confirmed 2026-10-06, see "Confirmed 2026-10-06" in the CR-020 section)
**Branch (decided 2026-10-06):** `feat/wave-12-bulk-users`, cut from `main`
(`df20b8f`, production). Only this file and the decision record come across
from `feat/waves-11-13`, so the PR into `main` is wave 12 alone: no wave 11
code and no T13.1, which must not reach `main` before T14.1. Wave 16 is not
merged yet; it touches different functions, and whichever lands second rebases.
Six tasks, in build order.
---
### T12.1 — CR-020: bulk endpoints
- **Items:** `CR-020`
- **Depends on:** nothing (first task)
- **Blocks:** T12.2, T12.4
- **Surface:** `server/`
- **Files:** `server/app.py`
**Do:** Add bulk variants of the four existing single-user actions — role
change, active/disabled, project assignment (add/remove + project-role), and
delete. Each takes a list of `user_id`s plus the action's parameters and
applies `require_see_user`/`require_manage_user`/`grantable_roles` **per row**,
exactly as the single-user endpoint does today — a super user's bulk request
cannot reach further than their existing single-user requests can. Do not skip
the self-action guard: an actor's own account is rejected out of any batch
that would disable, demote, or delete it, same as today.
Each successful row writes its own `AuditLog` entry via `log_event`, same
action names the single endpoints already use. A row that fails is reported in
the response (user id, reason) and does not stop the rest of the batch from
being attempted.
**Do not:** invent a single opaque "bulk_action" audit entry in place of the
per-row entries. Do not build a soft-delete path for bulk delete that doesn't
exist for the single case — bulk delete stays a hard delete, matching
`delete_user` today.
**Done when:**
- [x] each of the four bulk actions is callable with a list of user ids and a
single set of parameters
- [x] a batch containing the actor's own account rejects only that row, not
the whole batch — verified for disable, demote, and delete
- [x] a super user's batch that includes a user/project outside what they
manage rejects only that row, with a stated reason
- [x] every successful row produces its own `AuditLog` entry, identical in
shape to what the single-user endpoint would have written
- [x] a batch with some failing rows still applies to the rows that succeed,
and the response lists exactly which rows failed and why
---
### T12.2 — CR-020: row selection in the User Directory table
- **Items:** `CR-020`
- **Depends on:** T12.1
- **Blocks:** T12.3
- **Surface:** `html/`
- **Files:** `html/users.js`, `html/users.html`
**Do:** Add a checkbox per row and a select-all control, respecting whatever
filter (`role`, `active`/`disabled`, project) is currently applied — select-all
selects the filtered set, not every user in the system regardless of what's
shown. A bulk-action toolbar appears once at least one row is checked and
disappears at zero.
**Done when:**
- [x] select-all selects exactly the rows currently visible under the active
filter, not the full unfiltered table
- [x] changing the filter while rows are selected does something sane and
visible (either clears the selection or keeps it explicit which rows are
still selected) — pick one and state it, don't leave it undefined
- [x] the toolbar is keyboard-reachable and only present when >=1 row is
selected
---
### T12.3 — CR-020: bulk-action toolbar
- **Items:** `CR-020`
- **Depends on:** T12.2
- **Blocks:** T12.5
- **Surface:** `html/`
- **Files:** `html/users.js`
**Do:** Wire the toolbar to T12.1's endpoints for role change, activate/
disable, and project assignment (add to / remove from a project + project-
role). Confirmation before applying uses the `wp-dialog` kit (`T7.9`) —
`wpConfirmDialog`, not a native `confirm()` — naming exactly how many users are
affected. On completion, report per-row results if anything failed (T12.1
already returns this) rather than a single success/failure toast that hides a
partial failure.
**Delete is built separately, in T12.5** — do not wire delete here.
**Done when:**
- [x] role change, activate/disable, and project assignment each work end to
end against a multi-row selection
- [x] the confirmation dialog names the exact affected count before anything is
sent
- [x] a batch with a partial failure shows which rows failed, not just an
undifferentiated error
- [x] `aria-live` announces the outcome
---
### T12.4 — CR-020: CSV upload path
- **Items:** `CR-020`
- **Depends on:** T12.1
- **Blocks:** T12.6
- **Surface:** `html/` + `server/`
- **Files:** `html/users.js`, `server/app.py`
**Do:** An upload accepting a list of usernames plus the action to apply,
following the validate-and-report pattern `CR-005` established: reject and
report bad rows (username not found, actor lacks permission over that user)
rather than silently dropping them. This is a second entry point onto the same
T12.1 endpoints, not a third implementation of the bulk logic.
**Done when:**
- [x] a CSV with a mix of valid and invalid usernames applies to the valid
rows and reports the invalid ones by row, with a reason
- [x] the same permission/self-action guards from T12.1 apply here — a CSV
cannot reach a user a checkbox-driven batch couldn't
- [x] duplicate usernames in one CSV are handled without double-applying or
erroring confusingly
---
### T12.5 — CR-020: bulk delete confirmation
- **Items:** `CR-020`
- **Depends on:** T12.3
- **Blocks:** T12.6
- **Surface:** `html/`
- **Files:** `html/users.js`
**Do:** Wire delete into the toolbar with a heavier confirmation than the other
three actions, per the decision record's recommendation: list the affected
usernames and require typing a confirmation phrase (e.g. `DELETE`) before the
request is sent, regardless of how many rows are selected. This is flagged in
the decision record as a recommendation Matt has not explicitly signed off on
— if the PR reviewer wants a lighter or heavier mechanism, that's the moment to
change it, not a reason to skip building a real confirmation now.
**Done when:**
- [x] the affected usernames are listed in the confirmation dialog before
delete is sent
- [x] the request is not sent until the confirmation phrase is typed correctly
- [x] the actor's own account, if somehow selected, is rejected with a clear
reason rather than silently included or silently dropped
---
### T12.6 — CR-020: verification
- **Items:** `CR-020`
- **Depends on:** T12.4, T12.5
- **Blocks:** nothing
- **Surface:** `html/` + `server/`
- **Files:** as touched above
**Do:** Full verification per `CLAUDE.md`: run locally, exercise bulk role
change, activate/disable, project assignment, CSV upload, and bulk delete at
390px and 1440px, before/after screenshots, smoke test, `seed_demo.py`, full
suite.
**Done when:**
- [x] all `CR-020` acceptance criteria in `decisions-2026-09-17.md` are met or
a failure is stated with a reason
- [x] screenshots committed
- [x] smoke test and `seed_demo.py` both still pass
- [x] full test suite passes
---
## Wave 12 exit criteria
- [x] all four bulk actions work against both a checkbox selection and a CSV
upload
- [x] every existing single-user guardrail (self-action, scope, grantable
roles) holds under bulk use
- [x] bulk delete requires typed confirmation and lists affected usernames
- [x] partial failures are always reported, never hidden behind a blanket
success
- [x] `CR-020` fully accounted for, no open acceptance criteria
## Verification record
Built 2026-10-06 on `feat/wave-12-bulk-users`
(from `main`, `df20b8f`), one commit per task. Run in the build sandbox (Linux,
Python 3.10, no browser).
| Check | Result |
|---|---|
| `tests/bulk_users_check.py` (new, no browser) | **61/61**: all four actions, own-row refusals, super-user scope, per-row audit in the single route's shape, partial failure, project add/remove keeping other projects and roles, CSV resolve, 403/401/422 gates |
| Same check against `main` | 7/18: the 7 single-route checks pass; every bulk check fails, because the routes do not exist there |
| Single-user routes before/after (16 calls: 200/400/403/404, as admin and super user) | **Identical** responses, audit rows and memberships against `main`. The routes now call the same `apply_*` functions as the bulk routes |
| Page logic, DOM harness (jsdom, the real `users.html` and scripts, mocked API) | **48/48**: selection, select-all over the filtered rows, filter clears selection, toolbar, confirm counts, per-row report, CSV, typed DELETE |
| Same flows, jsdom against a real server seeded by `browser_check.seed()` | **13/13**, including the CSV report texts the browser probe expects |
| `server/smoketest.py` | **27/27** |
| `server/seed_demo.py` | Seeds the demo project |
**Decisions applied (confirmed 2026-10-06):** typed `DELETE`; project assignment
is add/remove per project, with the per-project role (`ProjectMember.role`) set
on add; filter or search change clears the selection; CSV holds usernames only.
A row already in the requested state reports `unchanged` and writes no audit
row (nothing changed). An email address in the CSV resolves only when exactly
one account has it.
**Found and logged, not fixed:** BL-060, a super user's refusal reason promises
a project-access change that neither the dialog nor the bulk route allows.
**Browser probes, run 2026-10-06 on Matt's machine (Windows, Chrome 153 / Edge 154,
`.venv`), one at a time:**
| Probe | Result |
|---|---|
| `tests/bulk_users_ui_check.py` (new) | **19/19**: selection, Space on a row box, role change, super-user CSV (another job / not found / herself / duplicate, each by line), add-to-project with a role, typed DELETE, 390px bar fit, no JS errors |
| `tests/console_dialogs_check.py` | **16/16**, including the new section 4 (bulk delete prompt, natives poisoned) |
| `tests/mobile_check.py` | **24/24**, users page included |
| `tests/a11y_check.py` | **22/22**: users page 66 focusable elements, all with a visible ring; helper text 5.02:1 at worst |
| `tests/browser_check.py` | **67/71**, then re-pointed (below); **rerun after the re-point: all passed** (reported by Matt, 2026-10-06) |
**`browser_check.py` re-pointed (T12.6).** Its four failures were assertions
written against column POSITIONS: the manager table had 9 columns, and the
own-row checks read `r.cells[3]` (Permissions) and `r.cells[4]` (Project role).
CR-020's selection column is first, so the table has 10 and those indexes
landed on Username and Email. Not an app defect. The probe now expects 10
columns with the selection column first, finds the two cells by their header
name rather than their position (so the next column cannot break it the same
way), and adds one check: your own row has no selection box. Verified against
the real page in the DOM harness, then rerun in the browser: all passed.
**Screenshots** (after; the before-shots are `baseline/users-1440.png` and
`baseline/after-wave9/users-390.png`): `baseline/wave-12/users-1440.png`,
`users-1440-selected.png`, `users-390.png`, `users-390-selected.png`. Reviewed:
the bar, its four groups and the selected-row marking render as designed at
both widths; nothing scrolls sideways at 390px.
**Seen in the screenshots, not caused by wave 12, logged as BL-061:** the
pre-existing sync badge ("Everything sent to the project", `project-data.js`)
is drawn over a row's Delete button at 1440px and over "Set permissions" at
390px for about 2 seconds after a load. It is `pointer-events:none`, so it never
blocks a click, but it hides a control while it shows.
**Wave 12 closed 2026-10-06.** Every task done-when and every exit criterion
above is checked. Pushed as `feat/wave-12-bulk-users`; PR into `main` open.
Merge after wave 16 (`feat/wave-16-on-main`); both orders tested conflict-free.

486
docs/waves/wave-13.md Normal file
View File

@@ -0,0 +1,486 @@
# Wave 13 — Okta/AD deprovisioning sync
**Items:** `D18`
**Depends on:** wave 10 merged (it is). Not blocked by wave 11 or wave 12, but
shares `server/app.py` account-state surface with wave 12 (`CR-020`) — sequence
commits to avoid an avoidable conflict.
**Decision record:** `docs/waves/decisions-2026-09-17.md`
Six tasks, in build order. **T13.3's fail-closed behavior is the most
important done-when list in this wave — do not relax it to ship faster.**
---
### T13.1 — D18: idle timeout with an absolute ceiling
- **Items:** `D18`
- **Depends on:** nothing (first task, independent of the rest)
- **Blocks:** nothing
- **Surface:** `server/`
- **Files:** `server/auth.py`, `server/app.py` (`auth_gate` middleware),
`server/.env.example`, `DEPLOYMENT.md`
**Revised 2026-09-23** — originally just "shrink `AUTH_SESSION_HOURS`". Matt
asked whether an idle timeout would be a better fit than a flat session
length. It is, but not by itself — see the decision record's reasoning on why
idle-with-no-ceiling is actually a worse fit for this item's own threat model
than a flat expiry would have been. Build both.
**Do:**
- Add `login_at` to the JWT payload in `create_token()` — the original
sign-in time, distinct from `iat`, which becomes "when THIS token was
issued" once tokens start getting reissued. `login_at` never changes across
reissues; it's what the absolute ceiling is measured from.
- Add `AUTH_IDLE_MINUTES` (default 30). `AUTH_SESSION_HOURS` stays the name
for the absolute ceiling, default changing from 12 to a proposed 8 — update
its docstring/comment in `auth.py` and `.env.example`, since its MEANING is
changing (session length -> hard ceiling on top of a sliding idle window),
not just its value.
- In `auth_gate` (`server/app.py`), after confirming a request is
authenticated: if `now < login_at + AUTH_SESSION_HOURS` (the ceiling hasn't
passed), compute `new_exp = min(now + AUTH_IDLE_MINUTES, login_at +
AUTH_SESSION_HOURS)`. If `new_exp` is meaningfully later than the current
token's `exp` (throttle this — do not reissue on every single request, only
when enough time has passed to be worth a new cookie; a few minutes of
slack is fine), mint a refreshed token carrying forward `sub`/`username`/
`role`/`ver`/`login_at` unchanged, and set it on the response.
- If the ceiling HAS passed, do not refresh — let the existing token expire
on its own terms (it may already be invalid, or may tick over within the
idle window; either way, no new one is issued past the ceiling).
- The middleware should not need a DB round trip to do this — everything
needed (`sub`, `username`, `role`, `ver`, `login_at`) is already in the
validated claims. `get_current_user`'s existing per-request `is_active`/
`token_version` check is unaffected and still runs separately.
**Do not:** reissue the cookie on every request unconditionally — that's a
`Set-Cookie` header on every API call for no benefit over a coarser refresh.
Do not let the ceiling check silently vanish for tokens issued before this
change ships — a token with no `login_at` claim should fall back to treating
its own `iat` as `login_at`, not bypass the ceiling entirely.
**Done when:**
- [x] a session with continuous activity stays alive past 30 minutes but is
cut off at the `AUTH_SESSION_HOURS` ceiling regardless
*(2026-10-16, T13.6: a request every minute for 10 hours: alive well past 30 minutes, never extended past login + 8 h, cut off at the ceiling, original `login_at` kept.)*
- [x] a session with no activity for 30+ minutes is rejected on its next
request
*(2026-10-16, T13.6: an idle token gets 401 on a gated route; one inside the window gets 200.)*
- [x] the cookie is not rewritten on every single request — verify the
refresh is throttled, not unconditional
*(2026-10-16, T13.6: 20 rapid requests on a fresh session: 0 rewrites; 480 requests over 8 h: about one rewrite per 10 minutes; a refreshed cookie is not rewritten again on the next request. Mutation test: removing the throttle fails 3 checks.)*
- [x] a pre-existing token with no `login_at` claim (simulating a session
issued before this shipped) still gets a hard ceiling, via the `iat`
fallback
*(2026-10-16, T13.6: a token with iat 9 h ago and a still-valid old exp is not extended; one with iat 1 h ago is refreshed with `login_at` taken from `iat`; no `login_at` and no `iat` is not refreshed and does not crash. Mutation test: giving it a fresh ceiling fails.)*
- [x] `.env.example` and `DEPLOYMENT.md` explain both variables and flag both
defaults as proposed, not confirmed against Okta's own session policy
*(2026-10-16, T13.6: both variables are in both files, and both call the defaults proposed.)*
- [x] existing session/auth tests updated for the new mechanism, not just a
new number
*(2026-10-16, T13.6: there were none. T13.1 shipped with no test of its own. `tests/session_idle_check.py` is that test (T13.6 added it).)*
---
**Found while writing that test (T13.6, 2026-10-16):**
- Nothing under `/api/auth/` slides the session. `auth._EXEMPT_PREFIXES` covers
that whole prefix, so `auth_gate` never refreshes there (including
`/api/auth/me`). A page that only called `/api/auth/me` would not extend its
session. The spec says "after confirming a request is authenticated", and these
routes are not confirmed by the gate, so this is as written. Noted, not changed.
- The wave's exit criteria below say `AUTH_SESSION_HOURS` defaults to **2**. T13.1
(this section), `auth.py`, `.env.example` and `DEPLOYMENT.md` all say **8**. The
code and the T13.1 text agree, so the exit line looks like a leftover from
before the 2026-09-23 revision. Not changed here: it is a product number. Needs
Matt to say which one he means.
### T13.2 — D18: Okta Management API client
- **Items:** `D18`
- **Depends on:** nothing (independent of T13.1)
- **Blocks:** T13.3
- **Surface:** `server/`
- **Files:** new `server/okta_sync.py` (or extend `server/okta_auth.py` —
task's call), `server/.env.example`
**Do:** A small client for Okta's user-list endpoint, authenticated with a new,
separate credential (e.g. `OKTA_API_TOKEN`) — not the OIDC client secret used
for sign-in. Fetch the full user list (paginated per Okta's API) rather than
one-by-one lookups per local user; this app has ~20-odd accounts today, and a
list-and-diff is simpler and cheaper than N calls. Return each Okta user's
identity-claim value (matching `OKTA_IDENTITY_CLAIM`, already confirmed live
per wave 10) and status.
Follow the existing pattern for external credentials in this repo (`MICRON_DB_URL`,
`SMTP_PASSWORD`): env-only, never logged, never returned to the browser in an
error message.
**Do not:** reuse `OKTA_CLIENT_ID`/`OKTA_CLIENT_SECRET` for this. Sign-in and
the management API are different trust boundaries with different scopes;
conflating them means a compromise or rotation of one affects the other
unnecessarily.
**Done when:**
- [x] the client authenticates with its own credential, distinct from the OIDC
client
*(2026-10-16: `OKTA_API_TOKEN`, sent as `Authorization: SSWS`. `tests/okta_sync_check.py` sets a different OIDC client secret and asserts it is never sent.)*
- [x] it fetches the complete Okta user list, handling pagination
*(2026-10-16: follows `Link: rel="next"`, 200 per page, 2-page case checked. A next link to another host is refused, a chain longer than 50 pages raises instead of cutting the list off, redirects are never followed.)*
- [x] an auth failure or malformed response raises a clear, specific error
rather than returning an empty list indistinguishable from "everyone was
deprovisioned" — this distinction is what T13.3 depends on
*(2026-10-16: `OktaSyncError` for HTTP 401/403/404/429/5xx, redirects, network errors, timeouts, non-JSON, non-list, a bad item (never skipped), and an empty list. 31 failure checks. Mutation test: making the client return `[]` on an error fails 10 of them.)*
- [x] the credential is never logged or surfaced in any API response
*(2026-10-16: error messages carry the class name and HTTP status only, never the URL or a header. `describe()` has no token. Nothing is wired to an API response yet; T13.4 wires the startup log.)*
---
### T13.3 — D18: the sync job
- **Items:** `D18`
- **Depends on:** T13.2
- **Blocks:** T13.4
- **Surface:** `server/`
- **Files:** `server/okta_sync.py`, `server/app.py` (or wherever `log_event`
lives)
**Do:** Compare the Okta user list (T13.2) against local `users` rows. For any
local `is_active=True` user whose Okta identity is missing from the list, or
present with a non-active status, set `is_active=False` and write an
`AuditLog` row (`actor="system:okta_sync"`, action e.g.
`user_deprovisioned_by_sync`, detail naming the Okta status found). Never
touch a user already `is_active=False`. Never re-enable anyone.
**The fail-closed rule, non-negotiable:** if T13.2's client raises an error of
any kind (network, auth, malformed response, timeout), this task takes **no
action on any account** for that run and logs the failure clearly (server log,
at minimum). An error is never treated as "Okta returned zero active users."
Write a test that asserts this directly: feed the sync a failing client and
assert zero rows changed and zero `AuditLog` entries written.
**Done when:**
- [x] a user missing from Okta's list, or present but not active, is disabled
with a correctly-detailed audit row
*(2026-10-16: see "Decided 2026-10-16" below for which statuses count as "not active". Audit row: actor `system:okta_sync`, action `user_deprovisioned_by_sync`, `entity_type` user, `detail` `{okta_status, via}`; a missing user is recorded as `MISSING`.)*
- [x] a user already disabled is left alone (no duplicate audit row each run)
*(2026-10-16: a second run over the same data writes no new rows.)*
- [x] an active Okta user already active locally produces no audit row (only
changes are logged, not a clean bill of health every cycle)
*(2026-10-16: verified in `tests/okta_sync_job_check.py`.)*
- [x] **a simulated Okta API failure results in zero account changes and zero
audit rows** — this is the one check that must never be skipped or
weakened
*(2026-10-16: 10 stand-in failures (OktaSyncError, RuntimeError, ConnectionError, TimeoutError, ValueError, KeyError, empty list, None, two kinds of garbage), 4 through the real client (HTTP 401/403/429/500), the default path with no token, a failed commit, and a wrong identity attribute. Each: `ok` is False, zero accounts changed, zero audit rows. Mutation test: removing the fail-closed branch and the zero-match guard fails 28 of these.)*
- [x] the job never re-enables an account under any input
*(2026-10-16: a disabled account that is ACTIVE in Okta stays disabled, and `okta_sync.py` contains no assignment of `is_active` to True.)*
---
**Decided 2026-10-16 (Matt, in chat):** which Okta statuses disable an account.
The spec says "a non-active status". Read literally, that also catches
`PASSWORD_EXPIRED`, `LOCKED_OUT` and `RECOVERY`, which people leave on their
own, and this job never re-enables, so one AD password expiry would lock someone
out of the app until an admin stepped in. Decided: an account disables when it is
**missing** from Okta's list, or every Okta entry for it is **SUSPENDED** or
**DEPROVISIONED** (`DISABLING_STATUSES` in `server/okta_sync.py`). Okta's default
user list already leaves out DEPROVISIONED users, so those arrive as "missing".
**Added 2026-10-16, inside decision 4's "anything the sync can't confidently
parse":** if there are active local accounts and **none** of them matches any
Okta user, the run is refused and nothing changes. That pattern means the
identity attribute is wrong (`OKTA_SYNC_PROFILE_ATTRIBUTE`), not that the whole
company left. It is a guard, not a new feature. Raise it in the PR.
**Open, for the PR / Nick:** which Okta profile attribute equals the
`preferred_username` claim in this tenant. The client assumes `profile.login`,
Okta's default. Confirm before the first live run. A wrong value is caught by the
zero-match guard above only when it matches nobody at all; a value that matches
some accounts and not others would disable the rest. See `BL-069`.
### T13.4 — D18: run it on a schedule
- **Items:** `D18`
- **Depends on:** T13.3
- **Blocks:** T13.6
- **Surface:** `server/`, `docker-compose.yml`
- **Files:** `server/app.py` (startup hook) or a new sidecar per the `backup`
container's pattern — task's call, per the decision record's noted
alternative
**Do:** Wire T13.3 to run on an interval (proposed 15 minutes, env-overridable
— e.g. `OKTA_SYNC_INTERVAL_SECONDS`, matching `BACKUP_INTERVAL_SECONDS`'s
naming). Default choice is an in-process background task in the `api`
container; if a separate container is chosen instead, follow the `backup`
service's shape (own Dockerfile or script, `internal` network plus whatever
egress reaching Okta requires — check whether `outbound` as currently defined
is sufficient or Okta needs a distinct allowance).
**Done when:**
- [x] the job runs automatically on the configured interval without manual
invocation
*(2026-10-16: a daemon timer thread starts from the app's lifespan hook (`server/app.py`), checks once a minute, and ran the sync on its own in `tests/okta_sync_schedule_check.py`. With `OKTA_API_TOKEN` unset it starts nothing and the startup log says `Okta sync DISABLED`. Booted the real app both ways; the thread starts and ends with the app.)*
- [x] interval is env-configurable with a sane default
*(2026-10-16: `OKTA_SYNC_INTERVAL_SECONDS`, default 900. A non-number uses the default. A value under 300 is raised to 300. Passed through `docker-compose.yml`.)*
- [x] a container restart does not produce a duplicate/overlapping run, and a
slow cycle does not stack with the next one
*(2026-10-16: the api runs 2 gunicorn workers, so each starts its own timer. One row in `app_settings` (key `okta_sync`) is the gate: a worker claims a cycle with one atomic conditional UPDATE, so exactly one wins. Checked with 8 racing workers on a file database, 15 rounds plus the first-insert race: exactly 1 winner every time. The row outlives a restart, so a restart inside the interval starts nothing. A slow run cannot overlap the next: a fetch is capped at 120 s in total and the interval cannot go below 300 s. Inside one process the thread runs one cycle at a time. This needed no migration: `app_settings` already exists.)*
---
**Decided 2026-10-16 (task's call, per this task's "Do"):** in-process timer in the
`api` container, as D18 proposed, not a sidecar. The `backup` pattern was the
alternative; it would need its own image and would not remove the 2-worker
duplicate question, because the sync reads the application database anyway.
**Network check, as the task asked:** the `outbound` network the `api` service
already joins is an ordinary bridge with a gateway, so Okta is reachable with no
network change. The host firewall must allow https to the Okta org.
**One change to T13.2's code:** `fetch_users()` now also stops after 120 seconds in
total (`TOTAL_DEADLINE_SECONDS`), which is what lets the scheduler promise no
overlap. Tested in `tests/okta_sync_check.py` section 8.
**T13.4 follow-up, 2026-10-16:** the sync's INFO log lines did not appear in
`docker compose logs api`. Nothing in the app configures Python logging, and
gunicorn configures only its own loggers, so INFO from any `wpsuite.*` logger is
dropped. The T13.4 check booted the app in-process with logging switched on,
which hid it. With the exact Dockerfile launch (2 gunicorn workers), a healthy
start printed zero Okta lines. `okta_sync.py` now gives its own logger one stderr
handler (only when the root logger has none). Re-run with the real gunicorn
command: `configured` and `scheduled` (or `DISABLED`) now print once per worker.
No other module's output changed. App-wide logging stays a separate question
(BL-028 is the same family).
### T13.5 — D18: admin visibility
- **Items:** `D18`
- **Depends on:** T13.3
- **Blocks:** T13.6
- **Surface:** `html/`
- **Files:** `html/users.js` / `html/admin.js` (wherever audit history is
already surfaced)
**Do:** Confirm an auto-disable reads clearly wherever admins already look at
account history — the actor string (`system:okta_sync`) should be
self-explanatory in context, not require reading server logs to understand.
Do not build new UI beyond making sure the existing audit surface renders this
actor sensibly. Email/notification to admins on auto-disable is a noted
fast-follow (the decision record flags it as open, not required here) — do not
build it in this task; log it instead if it's tempting to add.
**Done when:**
- [x] an auto-disabled account's audit entry is visible and legible in the
existing admin UI without special-casing
*(2026-10-16: run on the PC against the real page, 1440px and 390px, `tests/okta_sync_ui_check.py` 28/28. The admin Activity log card reads: Who `system:okta_sync`, Action `user deprovisioned by sync`, Type `user`, Item the username, Detail `okta_status: SUSPENDED, via: okta_sync` (a person missing from Okta reads `okta_status: MISSING`). Search for `okta_sync` and the User accounts filter both find the rows. No sideways scroll, no JavaScript errors. The disabled account is refused on its very next request; an account still active in Okta is not. A project super user does not see these rows: they belong to no project, so only admins do, the same as other user-management events. No code in `html/` changed.)*
- [x] nothing here silently assumes `CR-019`'s activity view exists yet — this
must work standalone
*(2026-10-16: the check reads only the Activity log (AuditLog) card. The new Activity & usage card is on the page but is not read.)*
---
**No UI was built.** The existing card renders the new rows legibly as is. Two
things you might expect and did not get, both on purpose: no admin email on an
auto-disable (D18 calls it a fast-follow; not built, not logged as a new item
because D18 already names it), and no per-user history view in the User
Directory (it has none today, and the task says not to build one).
### T13.6 — D18: verification
- **Items:** `D18`
- **Depends on:** T13.4, T13.5
- **Blocks:** nothing
- **Surface:** `server/`
- **Files:** as touched above
**Do:** Full verification per `CLAUDE.md`. Beyond the usual run: specifically
re-run T13.3's fail-closed test in isolation and confirm it still passes after
T13.4's scheduling wrapper is in place — the scheduling layer must not
introduce a path that swallows the client's error and proceeds anyway.
**Done when:**
- [ ] all `D18` acceptance criteria in `decisions-2026-09-17.md` are met or a
failure is stated with a reason
- [x] the fail-closed behavior is verified end to end through the scheduled
wrapper, not just the bare sync function
- [x] smoke test and `seed_demo.py` both still pass
- [x] full test suite passes (48 of 50; the two failures are the known ones, see the result note below)
---
## Wave 13 exit criteria
- [x] `AUTH_SESSION_HOURS` defaults to 8, documented (D25 replaced the 2 hours in this line; T13.1's idle timer is still held back)
- [x] the sync job runs on a schedule and correctly disables accounts Okta no
longer shows as active
- [x] every auto-disable is individually audited with a clearly non-human actor
- [x] an Okta API failure of any kind changes zero accounts — verified, not
assumed
- [x] the sync never re-enables an account
- [ ] `D18` fully accounted for, no open acceptance criteria
## Release note (2026-10-16)
T13.1 (commit `6cde6e3`) is held back from `main` until T14.1 lands, per the merge
rule in `wave-12.md`. The release branch contains wave 11 and T13.2 to T13.5.
`tests/session_idle_check.py` skips (exit 0) when `auth.maybe_refresh_token` is absent.
Sessions keep the flat `AUTH_SESSION_HOURS` lifetime (default 12) until T13.1 lands.
T13.6 result (2026-10-16, merged release tree, Edge on the PC): 47 test scripts, 45 pass.
The two failures are not regressions. `token_check.py` exits 2 (CLI usage detail).
`generalinfo_check.py` finds an old color-literal gap in `wp-creation-styles.css`.
Alembic upgrade, downgrade, upgrade passed. Import check passed.
## T13.7: D22 dry run for the Okta sync
**Item:** D22 (`docs/waves/decisions-2026-10-16.md`). Extends T13.3 and T13.4.
**Done when:**
- [x] `OKTA_SYNC_DRY_RUN` on: the sync fetches and matches, logs the accounts it would disable, and changes no account and writes no audit row (`tests/okta_sync_dry_run_check.py`)
- [x] both guards (zero match, fail closed) still apply in a dry run
- [x] flag off or unset: behavior is unchanged (`okta_sync_job_check.py` still passes)
- [x] the startup line names the mode
- [x] `.env.example`, `docker-compose.yml` and `DEPLOYMENT.md` describe the flag and the first-deploy steps
- [x] mutation check: if the dry-run guard is removed, the new test fails
Result 2026-10-16: all Okta sync tests and `security_check.py` pass in the sandbox.
This task changes no frontend file.
## T13.8: run the stack in Docker on a PC
**Item:** D22 (`docs/waves/decisions-2026-10-16.md`), as a way to check T13.7 and later builds before a deploy.
**Done when:**
- [x] one command starts the api, the database and the web server from the shipped compose file plus `docker-compose.local.yml`
- [x] `http://localhost:8080/api/health` answers 200 and `/api/projects` answers 401 without a session
- [x] every migration runs on Postgres (head `8e2cb3003f8a`)
- [x] the api log shows the `Okta sync` startup line
- [x] the steps are in `DEPLOYMENT.md`, "Run the stack on your own PC"
- [x] the shipped `docker-compose.yml` and nginx config are not changed
Result 2026-10-16 (Docker Desktop 29.7.2, Compose 5.4.0, Windows): passed. Three
things in the shipped files stop a local run. The override handles the first two
and the third is logged:
1. The web server publishes no port (the host's reverse proxy reaches it). The override publishes 8080 on loopback.
2. An existing `proxy` network on a PC can have no gateway, and Docker then does not publish ports. The override uses its own bridge. The stock nginx `default.conf` also answers "localhost" first and the app server answers only wp.controls.dev, so the override removes the stock file and makes the app server the default.
3. The backup container cannot start on Windows: `scripts/entrypoint.sh` has CRLF line endings (BL-070). The override turns the backup service off.
## T13.9: D23 sign in as an OAuth service app (private_key_jwt)
**Item:** D23 (`docs/waves/decisions-2026-10-16.md`). Extends T13.2.
**Done when:**
- [x] with `OKTA_SYNC_CLIENT_ID` and `OKTA_SYNC_PRIVATE_KEY`, the sync gets an access token and lists users with `Bearer` (`tests/okta_sync_oauth_check.py`)
- [x] the assertion verifies against the public key: `iss`, `sub`, `aud`, `kid`, life, `jti`
- [x] RSA and EC keys; JSON and base64 forms
- [x] a failed token request, a missing token, a DPoP token, a public key, or an unreadable key raises, and the users endpoint is never called
- [x] `OKTA_API_TOKEN` still works and wins when both are set
- [x] the startup line names the credential and holds no secret; no error message holds key text
- [x] mutation checks: Bearer to SSWS, wrong `aud`, DPoP accepted, public-key check removed: each makes the test fail
- [x] `.env.example`, `docker-compose.yml`, `DEPLOYMENT.md` describe the variables and the Okta app setup
Result 2026-10-16: sandbox, fake Okta. Not yet run against the real tenant.
No new dependency: PyJWT signs with `cryptography`, which Authlib already installs.
T13.9 follow-up (2026-10-16): the first live deploy failed with "OKTA_SYNC_PRIVATE_KEY is not a
JWK as JSON or as base64 of JSON". The first loader used strict base64, which rejects any
space or line break, and it gave one message for every failure. The loader now forgives quote
marks, spaces, line breaks, missing padding, the URL-safe alphabet, a byte-order mark and a
one-key JWK Set, and each failure names its step (counts only, no key text). The new checks
in `tests/okta_sync_oauth_check.py` fail against the first loader and pass now.
T13.9 follow-up 2 (2026-10-16): the second deploy decoded the value but the text was not JSON.
The loader now also names a PEM key, adds missing outer braces, unwraps a value that was encoded
twice, and its "not JSON" message gives the length and the kind of first character (counts only).
T13.9 follow-up 3 (2026-10-16): the third deploy decoded the base64 to 1,760 characters that start
with a brace, but Python's strict JSON reader refused them (PowerShell accepted the same text).
The loader now accepts control characters such as line breaks inside a string, curly quote marks and
a trailing comma, removes spaces inside the key's number fields, and a real syntax error reports the
line and column (position and rule only, never key text).
## T13.10: D24 DPoP for the Okta Management API
**Item:** D24 (`docs/waves/decisions-2026-10-16.md`). Extends T13.9.
**Done when:**
- [x] auto mode: a plain Bearer token is tried first; `invalid_dpop_proof` makes the sync retry with DPoP (`tests/okta_sync_dpop_check.py`)
- [x] each proof verifies: header (`dpop+jwt`, ES256, public jwk only), signature, `htm`, `htu` without query, current `iat`, one-time `jti`, `ath` on API calls, same key for token and API calls
- [x] nonce challenges at the token endpoint and at the API are answered once, and the retries are bounded
- [x] paging: a new proof for every page
- [x] mode `on` and mode `off`; a DPoP-bound token with mode off is refused; each run makes a new key
- [x] no secret in any message or the startup line; the SSWS path is unchanged
- [x] mutation checks: query kept in `htu`, `ath` omitted, `jti` reused, nonce not retried (token and API), private key in the proof header, and auto detection removed each make a test fail
- [x] `.env.example`, `docker-compose.yml`, `DEPLOYMENT.md` updated
Result 2026-10-16: sandbox, strict fake Okta. Not yet run against the real tenant.
## Live run and final verification (2026-10-17)
**Live deploy.** The api container runs the build from `main` (`1a3468e`) in Portainer. It signs in with the
service-app key (`private_key_jwt`) and DPoP. The first dry run (2026-10-17 18:31) fetched 2,564 Okta users and
checked 42 active local accounts. 41 matched (so `profile.login` is the right attribute) and 1 would be disabled:
`admin`, Okta status MISSING. Matt confirmed that `admin` is a leftover account, and switched the dry run off.
Live run log lines (api log):
- 18:46:21 `Okta sync disabled 'admin' (Okta status: MISSING)`, then `done: 2564 Okta user(s), 42 active local account(s) checked, 1 disabled`
- 19:01:50 `done: ... 41 active local account(s) checked, 0 disabled`
- 19:16:30 `done: ... 41 active local account(s) checked, 0 disabled`
This shows: the job runs on its schedule (every 900 seconds), it disables an account that Okta no longer lists, a
disabled account is not touched again and gets no new row, and the account count fell from 42 to 41.
The first session logs of fail-closed behavior are in the earlier runs: with a rejected token, a bad key, and an
unreadable key, the sync logged `SKIPPED, no account was changed` every time and no account changed.
**Admin recovery.** `python -m server.manage_users list | promote | enable | disable` works from the Portainer
console of `wp_api` (no `docker compose exec` prefix). `promote` changes an existing account. It does not create one.
**Full verification on the final tree (`1a3468e`).**
- Test suite on Matt's PC (Edge): 50 scripts, 48 pass. The two failures are not regressions:
`token_check.py` exits 2 (it needs `--out` or `--compare`), and `generalinfo_check.py` finds an old colour literal
(`rgba(`) in `wp-creation-styles.css`.
- `server/smoketest.py`: 27 of 27 checks pass. `server/seed_demo.py`: runs clean. Both ran in the sandbox against
a throwaway SQLite database. Note: use `http://127.0.0.1:PORT`, not `http://localhost:PORT`, because Python's cookie
jar does not send a cookie set for `localhost` (logged as BL-071).
- The Okta tests (`okta_sync_check`, `_job_`, `_schedule_`, `_dry_run_`, `_oauth_`, `_dpop_`, `_ui_`) and `security_check.py` pass.
**Still open for wave 13.**
- `T13.1` (idle timeout) is held back from `main` until T14.1 lands. The exit criterion "`AUTH_SESSION_HOURS` defaults to 2"
is not met, and it conflicts with T13.1's own text (8 hours). Matt has not chosen.
- ~~"Every auto-disable is individually audited with a clearly non-human actor" was not checked after the live run.~~
Checked 2026-10-17: the Admin Console activity list shows one row, actor `system:okta_sync`, action "user deprovisioned
by sync", item `admin`, detail `okta_status: MISSING, via: okta_sync`, at 11:46 AM local (18:46 UTC).
- `D18` cannot be called fully accounted for while T13.1 is outstanding.
- `BL-069` (a cap on one run and a last-admin guard) is open.
## T13.11: D25 the session limit is 8 hours
**Item:** D25 (`docs/waves/decisions-2026-10-16.md`).
**Done when:**
- [x] `AUTH_SESSION_HOURS` defaults to 8 in `server/auth.py`, `docker-compose.yml`, `server/.env.example`, `DEPLOY-login-portal.md` (`tests/session_default_check.py`)
- [x] the token expiry and the cookie max-age follow it; a set value overrides it
- [x] mutation check: putting the default back to 12 makes the test fail
- [x] the wave 13 exit criterion that said 2 is updated
Effect on the live system: after the next deploy, sessions last 8 hours instead of 12. To get the same result
before a deploy, set `AUTH_SESSION_HOURS` to `8` in the Portainer stack variables.
## Gate for T13.1 (2026-10-17)
T13.1 now has a written gate: `docs/waves/wave-14.md`. It lands in T14.4, after T14.1 (a `401` holds the outbox and does not
destroy it) and T14.2 (the offline window follows the server) are done. The reason is a fault found in the outbox on
2026-10-17: it marks a `401` as a permanent rejection, so an idle timeout would reject a crew's queued changes for good.
That fault already exists with the 8 hour limit, to a lesser degree.

190
docs/waves/wave-14.md Normal file
View File

@@ -0,0 +1,190 @@
# Wave 14: The outbox keeps every change, and the sign-in limit cannot destroy it
**Items:** `D26`, `D27`, `BL-061` (`B5` is context only: its wording rules stay, and this wave does not widen it)
**Depends on:** wave 13 merged (it is, except T13.1). Independent of wave 15.
**Decision record:** `docs/waves/decisions-2026-10-17.md` (D26 and D27 are **accepted** as of 2026-10-17, see "Open questions")
**Unblocks:** `T13.1` (idle timeout). T13.1 must not reach `main` before T14.1 and T14.2 are done.
**Branch rule:** one task for each pull request. Cut each branch from `main`.
## Why this wave exists
The outbox in `html/project-data.js` queues each save in `localStorage` and sends it later. A crew in the field
can work with no signal, and the changes go out when the network returns. The code was checked on 2026-10-17
against the 8 hour session limit (D25) and the idle timeout that T13.1 adds. It has four faults that lose or hide
work. They are small now. The idle timeout would make them common.
| # | Fault | Where | Result |
|---|---|---|---|
| 1 | A `401` (session ended) or `403` is treated like any other `4xx`. The change is marked **dead** and is never sent again. | `project-data.js`, `flush()` | A crew that works past the session limit, or past an idle timeout, comes back online and every queued change is rejected for good. The badge says "rejected by the project". The change is not lost from the device, but nothing can send it. |
| 2 | `qWrite()` swallows a storage error. | `project-data.js`, `qWrite()` | If the device storage is full, a change is **not queued and nobody is told**. |
| 3 | The queue belongs to the browser, not to a person. A queued change has no owner. | `project-data.js`, `enqueue()` | On a shared device, person B signs in and the queue of person A is sent under the name of person B. |
| 4 | The offline sign-in window is a fixed 12 hours in the browser. | `auth-guard.js`, around line 183 | It does not follow `AUTH_SESSION_HOURS` (8 since D25). It also slides: every online page load resets it. The browser and the server disagree about when the session ends. |
Also: the sync badge sits over page controls (`BL-061`) and cannot be used with a keyboard or a finger. The
badge is a `div` with `pointer-events:none`. A badge that must ask a person to sign in again needs a real link or button.
## Rules for this wave
- Do not use a `div` with `onclick` (`CLAUDE.md`, accessibility). The sign-in action is an `<a>` or a `<button>`.
- Status text goes in an `aria-live` region. The badge already has `role="status"`. Keep it.
- Server work is needed for T14.2 (one new field). Do not store session data in `localStorage` as the source of truth.
- Colors, spacing and type come from the shared tokens. Do not add a raw hex value to a page stylesheet.
- Frontend checks: run the app on a throwaway SQLite database, check at 390 px and 1440 px, capture before and after
screenshots, run the smoke test (use `http://127.0.0.1`, see `BL-071`).
- Do not fix other problems you see. Log them in `docs/waves/backlog.md`.
---
### T14.1: D26 a sign-in problem never destroys a queued change
- **Items:** `D26`
- **Depends on:** nothing (first task)
- **Blocks:** T14.2, T14.3, T13.1
- **Surface:** `html/`
- **Files:** `html/project-data.js`, `html/auth-guard.js`, a new `tests/outbox_check.py`
**Do:**
1. In `flush()`, treat `401` as **held**, not dead. Stop the run. Do not add to `tries`. Do not mark any change
dead. Keep the whole queue in its order. Set a "held for sign-in" state that the badge can read through
`ProjectData.syncStatus()` (add a field, for example `held: true`).
2. Keep `403` as a permanent refusal, but say why in the reason text ("you no longer have access to this project").
Keep `409` (archived project) and the other `4xx` as they are.
3. When the person signs in again (the page loads with a good session, or `wp-auth-ready` fires), clear the held
state and flush at once. The `online` event, the 20 second timer and the tab-focus trigger must **not** clear it
early: a held queue sends only after a good session check.
4. Make `qWrite()` return `true` or `false`. If it fails, `enqueue()` must tell the caller and raise the
`device full` state. The change stays in the page memory and the form stays open. The badge says the change is
**not saved on this device**. Do not drop it silently.
5. Give each queued change an `owner` (the signed-in username) when it is queued. At flush time, if `WP_USER` is not the
owner, hold that change and name the owner in the message. Do not send it. Do not discard it. (See open question 1.)
6. Make sure `auth-guard.js` does not delete the queue when it sends a person to `login.html` after a `401`. It must
keep `wp_sync_outbox_v1`.
**Done when:**
- [x] a queue of N changes meets a `401`: all N are still in the queue, none is dead, `tries` did not change, and the badge state is "held"
- [x] after a good sign-in, all N changes reach the server in their original order, and the queue is empty
- [x] a `403` marks only that change dead, with a reason that names the cause
- [x] a full device store (a forced `QuotaExceededError`) is reported to the caller and the badge. No change disappears silently
- [x] a change queued by person A is not sent when person B is signed in; it is sent after A signs in
- [x] `tests/outbox_check.py` covers each case above and fails when `flush()` is put back to the old rule (a mutation check)
- [x] the full suite passes (2026-10-17: 52 of 54 checks pass; the 2 others are `generalinfo_check` and `token_check`, known and not regressions). `mobile_check` covers 390 px. No before and after screenshots were taken: the badge looks the same until T14.3. The badge words for the new states are plain text. T14.3 gives them their final wording and the Sign in control.
**Built (2026-10-17):** commit `73f0b5e`. Open question 1 as accepted: another person's changes are held and the badge names the owner. A change queued before the sign-in check finished has no owner and can be sent by anyone, as before.
---
### T14.2: D27 the offline sign-in window follows the server
- **Items:** `D27`
- **Depends on:** T14.1
- **Blocks:** T13.1
- **Surface:** `server/` and `html/`
- **Files:** `server/app.py` (`whoami()`), `html/auth-guard.js`, `html/wp-format.js` (line 223 writes the cache), tests
**Do:**
1. Add one field to `/api/auth/me`: `session_expires_at` (the `exp` claim of the session, as a UTC time). Read the claim from the
token that `get_current_user` already validated. Do not add a database column. When T13.1 lands, this field is the
current `exp` and moves with each refresh.
2. In `auth-guard.js`, store `session_expires_at` in `wp_auth_cache`. Replace the fixed `12 * 3600 * 1000` with a rule
that uses it. The rule for this wave (see open question 2):
- offline, the app **opens** while the current time is before `session_expires_at`;
- after that time, offline, the app still opens in a **read and queue** mode: the person can see cached data and add
changes, which go to the outbox and are held (T14.1) until a good sign-in. The app does not go to `login.html`
while it has no network, because that page cannot load an Okta sign-in without a network;
- online, a `401` goes to `login.html` as now, and the outbox is kept (T14.1).
3. Stop sliding the window. A page load must not extend `wp_auth_cache`. Only the server can extend a session.
4. Show the person which mode they are in. One line: "Working offline. Sign in again when you have a signal to send your changes."
Use the same `aria-live` region as the badge.
**Done when:**
- [x] `/api/auth/me` returns `session_expires_at`, and it matches the token (`tests/session_expiry_check.py`, no database change)
- [x] the fixed 12 hours is gone from `auth-guard.js`
- [x] opening the app offline before the time works; opening it offline after the time gives read-and-queue mode and does not redirect
- [x] online with a dead session: redirect to `login.html?next=...`, queue kept, changes sent after sign-in (the send after sign-in is the T14.1 test, section 3)
- [x] a page load does not extend the cached window
- [x] the mode line is announced by a screen reader (`aria-live`) and fits at 390 px. The line is in the badge, which has `role="status"`. T14.3 checks that it fits at 390 px and covers no control (`sync_badge_check.py`, state `readqueue`). It was **not** tried with a real screen reader.
**Built (2026-10-17):** `tests/session_expiry_check.py` (22 checks) fails when the old 12 hour rule is put back (7 failures). The mode line shows only in read-and-queue mode, not when the app opens offline before the session ends, because "sign in again" would be wrong while the session is still good. In read-and-queue mode the outbox does not send at all until a page load gets a good answer from the server. Saving display preferences refreshes the cached user and keeps the end time (`wpCacheAuth`).
---
### T14.3: D26 and BL-061 the sync badge shows the true state and gets out of the way
- **Items:** `D26`, `BL-061`
- **Depends on:** T14.1
- **Blocks:** nothing
- **Surface:** `html/`
- **Files:** `html/project-data.js` (`renderSyncBadge`), `html/wp-chrome.css` or the shared token file, `tests/a11y_check.py`, `tests/autosave_check.py` (it reads the badge strings)
**Do:**
1. Show these states, each with its own words that name the **project**, never a draft save (the `B5` rule that wave 4 set): `sending`, `retrying`,
`held for sign-in` (with a link or button "Sign in"), `not saved on this device` (store full), `rejected` (with the reason),
and `all sent` (hides after a short time).
2. Make the badge usable: the "Sign in" and "Dismiss" controls are `<a>` or `<button>` elements with a visible focus ring
and a touch target of at least 44 px. Remove `pointer-events:none` for the states that have controls.
3. Keep the badge clear of page controls (`BL-061`): do not show it on pages that have no outbox work (the console
pages), and place it so that it does not cover the bottom-right action buttons at 390 px or 1440 px.
4. Keep text contrast at 4.5:1 or better in every state.
5. Update the tests that read the badge text (`autosave_check.py` reads its symbols; `a11y_check.py` reads the element).
**Done when:**
- [x] each state shows in a browser test, with its text (`tests/sync_badge_check.py`). The states are checked at 1440 px; the placement is checked at 390 px and 1440 px
- [x] "Sign in" is a real link (`<a>`), reachable by keyboard, 44 px or more, with a focus ring, and goes to `login.html?next=...`. Touch is covered by the size and by the element type: no touch event was sent
- [x] the badge covers no control on the User Directory or the bulk bar: the console pages never show it (`data-wp-no-sync-badge`)
- [x] no badge on the console pages
- [x] the contrast check passes for every state (4.5:1 or better, light theme only; the dark theme was **not** checked)
- [x] `autosave_check.py` and `a11y_check.py` pass. Full suite 2026-10-17: 53 of 55 pass; `generalinfo_check` and `token_check` fail as before (known, not regressions). `sync_badge_check.py` (87 checks) fails when the "nothing to send" rule and the console opt-out are removed (3 failures)
**Built (2026-10-17):** the badge words are in one function, `badgeModel()`. The mode line for read-and-queue mode now says "...to send your changes to the project." so it follows the B5 rule. "Dismiss" removes only the changes the project refused, after the person presses it. The badge picks a free spot on the screen (BL-061). One case is left, a very dense screen with no free gap: `BL-072`. No before and after screenshots were taken: the check measures overlap in the browser instead. A person should look at the badge once on a phone.
---
### T14.4: verify the wave and release T13.1
- **Items:** `D26`, `D27`, `BL-061`, `T13.1`
- **Depends on:** T14.1, T14.2, T14.3
- **Blocks:** nothing
**Do:** Run the full suite, the smoke test and `seed_demo.py`. Then test the real case by hand on a phone or tablet:
sign in, set the device to airplane mode, make three changes in Field View, wait until the session limit has passed
(use `AUTH_SESSION_HOURS=1` on a test stack with a clock change, or a forced expiry), turn the network on, and check that the badge shows
"held for sign-in", that signing in sends all three, and that the server has them. Then rebase `feat/waves-11-13`
T13.1 (`6cde6e3`) onto `main`, run `tests/session_idle_check.py` and the same hand test with the idle timeout on, and merge T13.1 as its own pull request.
**Done when:**
- [ ] the hand test passes on one iPhone and one Android device (or the failure and the reason are written here)
- [ ] the full suite and the smoke test pass on the final tree
- [ ] T13.1 is on `main`, and `tests/session_idle_check.py` runs (it no longer skips)
- [ ] the wave 13 exit line about D18 is ticked
---
## Open questions
**Answered 2026-10-17 (Matt accepted the proposal for questions 1, 2 and 3).** Question 4 is still open and belongs to `T13.1`.
1. **Shared devices.** If person B signs in on a device that holds unsent changes from person A, what must happen?
Proposed: hold A's changes, name A in the badge, send them when A signs in. Do not send them as B and do not discard them.
Other choices: allow B to discard A's changes after a confirmation; or send them as B (not proposed, wrong author in the log).
2. **Offline window.** Proposed for this wave: the app opens offline until the session ends, and after that works in read-and-queue mode.
The 7 day offline window (`BL-062`, Q2) is a **later** wave. Do you accept this order, or must 7 days come first?
3. **Device full.** Proposed: do not drop the change, keep it in the page memory, and tell the person. Is "tell the person and keep the
form open" enough, or must the app also stop new edits?
4. **Idle time.** T13.1 proposes 30 minutes. It is a proposed value, not a decision. It matters here because every minute of idle
time offline ends the session on the server side.
## Wave 14 exit criteria
- [ ] a session that ends while changes are queued loses none of them
- [ ] a full device store is never silent
- [ ] a change is sent only under the signed-in person who made it
- [ ] the offline window follows the server (no fixed 12 hours in the browser)
- [ ] the badge shows the true state, is usable, and covers no control
- [ ] T13.1 is merged to `main` and `D18` is fully accounted for

155
docs/waves/wave-16.md Normal file
View File

@@ -0,0 +1,155 @@
# Wave 16 — Urgent security fixes
**Items:** `D19`, `D20`, `D21`
**Depends on:** nothing. Independent of waves 12 to 15 (see the decision record).
**Decision record:** `docs/waves/decisions-2026-10-02.md`
**Background:** `docs/reference/security-review-2026-10-01.md`
Four tasks, in build order. All server-side. No page markup or stylesheet
changes, so the 390px / 1440px screenshot rule does not apply; the
browser probes that read files and SOPs are still listed for a run on a
machine with Edge.
New check for this wave: `tests/security_check.py`. It is self-contained (its
own SQLite database, in-process, no browser), so it runs anywhere.
---
### T16.1 — D21: session decode fails closed; PyJWT 2.15.1
- **Items:** `D21`
- **Depends on:** nothing (first task)
- **Blocks:** T16.4
- **Surface:** `server/`
- **Files:** `server/requirements.txt`, `server/auth.py` (`decode_token`), `tests/security_check.py` (new)
**Do:** pin `PyJWT==2.15.1`. In `decode_token`, return `None` for an empty or
over-long token (over 4096 characters) and for any exception from
`jwt.decode`. Require the `exp` and `sub` claims.
**Do not:** change token contents, the cookie, or the D18 refresh.
**Done when:**
- [x] the crafted-cookie request returns 401, not 500
- [x] a valid session still works, and the D18 refresh still reissues
- [x] `pip-audit -r server/requirements.txt` reports no PyJWT advisory
- [x] smoke test 27/27
---
### T16.2 — D19: uploaded files download safely
- **Items:** `D19`
- **Depends on:** nothing
- **Blocks:** T16.4
- **Surface:** `server/`
- **Files:** `server/files_http.py` (new), `server/app.py` (`get_wp_file`), `tests/security_check.py`
**Do:** serve PDF and raster images inline as today. Serve every other type,
SVG included, as an attachment with `Content-Security-Policy: sandbox;
default-src 'none'`. Send `X-Content-Type-Options: nosniff` from the API too
(NGINX already does; the dev server does not). Build `Content-Disposition`
with an ASCII fallback and an RFC 5987 `filename*`. Reference code:
`docs/reference/architecture-review/proposals/server/files_http.py` (P-6).
**Do not:** refuse SVG uploads (decided: accept, download only). Do not change
`Cache-Control`.
**Done when:**
- [x] an SVG downloads as an attachment with the sandbox header
- [x] PNG, JPEG and PDF still open inline
- [x] `Plan é.pdf` downloads (was 500)
- [x] a name with CR/LF produces a valid header
- [x] `tests/files_check.py` passes on a machine with Edge (CR-007 offline drawings)
---
### T16.3 — D20: one SOP per project
- **Items:** `D20`
- **Depends on:** nothing
- **Blocks:** T16.4
- **Surface:** `server/`
- **Files:** `server/app.py` (`upsert_sop`, `latest_sop`, `project_summary`, `project_sop_team`, `project_qa_group`), `tests/security_check.py`
**Do:** the four rules in D20. One helper picks the project's baseline SOP
(canonical row if complete, else latest complete) and every baseline reader
uses it.
**Do not:** delete or rename existing SOP rows. Do not change any response shape.
**Done when:**
- [x] a `project_user` cannot create a second SOP on a project (400) or post
`complete: true` while a complete SOP exists (403)
- [x] a `project_user` can still draft and complete the first SOP of a project
- [x] a Project Admin can still change the completed SOP
- [x] POST without an id lands on `sop__<project_id>`
- [x] a rogue complete SOP made before the fix no longer drives the baseline
or the QA and PM/CM recipients
- [x] `tests/sample_check.py` and `tests/critical_reopen_check.py` pass on a
machine with Edge
---
### T16.4 — D19, D20, D21: verification
- **Items:** `D19`, `D20`, `D21`
- **Depends on:** T16.1 to T16.3
- **Surface:** verification
- **Files:** this file (verification record)
**Done when:**
- [x] `tests/security_check.py` passes
- [x] `docs/reference/security-review/sec_probe.py`: S3 and S12 change as
expected; every other line is unchanged
- [x] the architecture review `equivalence_check.py` (current branch vs wave
16) is IDENTICAL: the scenario does not use these paths, so it proves the
rest of the work-package flow did not move
- [x] smoke test 27/27
- [x] the browser probes named in T16.2 and T16.3 are listed for a run on a
machine with Edge (not available in the build sandbox)
## Verification record
Run 2026-10-02 in the build sandbox (Linux, Python 3.10, no browser), on branch
`feat/wave-16-security` at T16.3.
| Check | Result |
|---|---|
| `tests/security_check.py` | **36/36** (D21 6, D19 14, D20 16) |
| Same check against `da1325c` with PyJWT 2.13.0 | 20/36. The 16 failures are the findings (D21 3, D19 6, D20 7). The 20 passes are the "still works" checks plus three that already held (over-long cookie 401, non-member 404, SOP move refused by the existing completed-SOP rule) |
| `docs/reference/security-review/sec_probe.py`, before vs after | Exactly 4 of 27 lines change: S3 (new complete SOP 200 -> **400**; baseline `sop_rogue` -> **`sop__proj_a`**; QA group attacker -> **real group**) and S12 (crafted cookie 500 -> **401**). All other lines identical |
| `equivalence_check.py` (architecture review), `da1325c` vs wave 16 | **IDENTICAL**: 78 HTTP results, 89 audit rows, 24 notifications. The scenario's SOP id was changed from `sop_eq` to the canonical `sop__proj_eq` on both sides, because D20 refuses a non-canonical id on purpose |
| `server/smoketest.py` | **27/27** after each of T16.1, T16.2, T16.3 |
| `server/seed_demo.py` | Seeds the demo project; its SOP lands on the canonical id |
| `pip-audit -r server/requirements.txt` | No known vulnerabilities |
**Browser probes, run 2026-10-02 on Matt's machine (Windows, Edge 154,
Python 3.12.10, `.venv`), one at a time:**
| Probe | Task | Result |
|---|---|---|
| `tests/files_check.py` | T16.2 | **36/36**, including the 1440px creator, 390px Field View, and the offline drawing cache with the server gone |
| `tests/sample_check.py` | T16.3 | **10/10** |
| `tests/critical_reopen_check.py` | T16.3 | **11/11**, PM + CM + assignee mail, sink-verified |
T16.2 and T16.3 are done.
**Production data check for D20, 2026-10-02.** On the production database
(`wp_db`, psql): projects with more than one complete SOP: **0 rows**. D20 has
no legacy duplicates to handle on deploy.
**Harness fix needed to get there (`tests/cdp.py`, committed with this record).**
Every probe failed first with "browser would not start ... exited rc=0
without binding the port". Cause: the PowerShell session was elevated, and
Edge and Chrome de-elevate by relaunching themselves through Explorer as a
normal user; the relaunch drops `--remote-debugging-port`. Edge's log said so
(`Edge is running elevated: 1`). No browser policy was involved (all hives
checked). Two changes, both inert on a normal shell and on Linux/macOS:
`--do-not-de-elevate` on Windows, and a 15-second grace for the port when the
launched process exits rc=0. Probe results are unchanged by it; it only lets
the browser start.

View File

@@ -34,12 +34,12 @@
/* Every container admin.js paints a table into is a scrollport of its own, so a
sticky header always has something to stick to rather than sliding up behind
the app bar. Same rule as console.css's .tscroll. */
#comments-admin, #audit-admin, #notif-box, #usage-admin, #projects-table, #defmem-table{
#comments-admin, #audit-admin, #notif-box, #activity-admin, #projects-table, #defmem-table{
overflow:auto; max-height:min(70vh,640px); overscroll-behavior:contain; }
/* If admin.js wraps its table in its own .tscroll, the outer box steps aside so
one table never ends up with two scrollbars. */
#comments-admin:has(.tscroll), #audit-admin:has(.tscroll), #notif-box:has(.tscroll),
#usage-admin:has(.tscroll), #projects-table:has(.tscroll), #defmem-table:has(.tscroll){
#activity-admin:has(.tscroll), #projects-table:has(.tscroll), #defmem-table:has(.tscroll){
overflow:visible; max-height:none; }
/* Comment text and audit detail are the two columns you are actually here to
@@ -53,12 +53,12 @@
border:1px solid var(--border-strong); border-radius:0; margin-bottom:var(--s3); }
@media (max-width:900px){
#comments-admin, #audit-admin, #notif-box, #usage-admin, #projects-table, #defmem-table{
#comments-admin, #audit-admin, #notif-box, #activity-admin, #projects-table, #defmem-table{
max-height:none; }
}
</style>
</head>
<body>
<body data-wp-no-sync-badge>
<!-- SHARED DARK APP BAR -->
<header class="wp-appbar">
@@ -175,16 +175,38 @@
<div id="audit-admin" class="note">Click refresh to load.</div>
</div>
<!-- USAGE LOGS -->
<!-- ACTIVITY &amp; USAGE (CR-019) -->
<div class="card">
<h2>Usage logs</h2>
<div class="sub">Engagement recorded by both tools — the work package creator and the SOP wizard —
sessions, actions and counts, with a download per tool (D5). Note: stored locally per browser,
so this reflects activity on <strong>this</strong> machine.</div>
<h2>Activity &amp; usage</h2>
<div class="sub">Who is using the suite, which tools, and how often — recorded server-side on every
sign-in and page open, kept indefinitely. Filter below, or export a CSV: raw (real usernames) for
internal use, or sanitized (each user replaced with a stable, non-reversible id) for feeding into
Power BI or another external reporting tool without carrying real identities.</div>
<div class="toolbar">
<button onclick="loadUsage()">Refresh</button>
<label for="act-from">From</label>
<input type="date" id="act-from" onchange="loadActivity()">
<label for="act-to">To</label>
<input type="date" id="act-to" onchange="loadActivity()">
<select id="act-project" onchange="loadActivity()"><option value="">All projects</option></select>
<input id="act-user" placeholder="Username…" oninput="loadActivity()">
<select id="act-tool" onchange="loadActivity()">
<option value="">All tools</option>
<option value="launcher">Launcher</option>
<option value="wizard">SOP wizard</option>
<option value="creator">Work package creator</option>
<option value="field_view">Field view</option>
<option value="admin">Admin console</option>
<option value="directory">User directory</option>
</select>
<button onclick="loadActivity()">Refresh</button>
</div>
<div id="usage-admin" class="note">Click refresh to load.</div>
<div id="activity-banner" class="banner" style="display:none"></div>
<div id="activity-admin" class="note">Loading…</div>
<div class="toolbar" style="margin-top:var(--s3)">
<button onclick="exportActivity(false)">Download CSV (raw)</button>
<button onclick="exportActivity(true)">Download CSV (sanitized)</button>
</div>
<div id="activity-export-banner" class="banner" style="display:none"></div>
</div>
<!-- DB SNAPSHOT -->
@@ -215,7 +237,6 @@
</div>
</div>
<script src="wp-usage.js"></script>
<script src="console-util.js"></script>
<script src="wp-dialog.js"></script>
<script src="admin.js"></script>

View File

@@ -24,7 +24,7 @@ function reveal(){
loadNotifications();
loadComments();
loadAudit();
loadUsage();
loadActivity();
}
function showDenied(){
document.getElementById('admin-denied').style.display='';
@@ -189,6 +189,19 @@ async function loadProjects(){
banner.style.display='none';
_adminProjects = json;
renderProjects();
populateActivityProjectFilter();
}
// The activity project filter reuses the same project list the Projects card
// already fetched — no second /api/projects call just to fill a <select>.
function populateActivityProjectFilter(){
const sel = document.getElementById('act-project');
if(!sel) return;
const cur = sel.value;
sel.innerHTML = '<option value="">All projects</option>' +
_adminProjects.slice().sort((a,b)=>String(a.name||'').localeCompare(String(b.name||'')))
.map(p => '<option value="'+uesc(p.id)+'">'+uesc(p.name||p.number||p.id)+'</option>').join('');
sel.value = cur;
}
function renderProjects(){
@@ -465,6 +478,90 @@ function renderAudit(){
'</tr>').join('')+'</tbody></table>';
}
// ── activity & usage (CR-019) ────────────────────────────────────────────────────
// Server-side, per-user activity — distinct from the "Activity log" card above
// (that's AuditLog: business mutations) and from the "Usage logs" card below
// (that's per-browser localStorage, D5/T7.10, on the way out per T11.6). This is
// /api/usage/summary and /api/usage/export: real rows, aggregated server-side,
// filterable by date/project/user/tool, and exportable raw or sanitized.
function _activityFilters(){
const q = new URLSearchParams();
const from = document.getElementById('act-from').value; if(from) q.set('from', from);
const to = document.getElementById('act-to').value; if(to) q.set('to', to);
const proj = document.getElementById('act-project').value; if(proj) q.set('project_id', proj);
const user = (document.getElementById('act-user').value||'').trim(); if(user) q.set('username', user);
const tool = document.getElementById('act-tool').value; if(tool) q.set('tool', tool);
return q;
}
async function loadActivity(){
const banner = document.getElementById('activity-banner');
const box = document.getElementById('activity-admin');
if(!box) return;
banner.style.display='none';
box.textContent = 'Loading…';
const { status, json } = await api('GET', '/api/usage/summary?'+_activityFilters().toString());
if(status===403){
banner.className='banner bad'; banner.style.display='';
banner.textContent = '✕ Your account can’t see suite-wide activity here — this needs admin, or Project Super User on at least one project.';
box.innerHTML=''; return;
}
if(status!==200 || !json){
banner.className='banner bad'; banner.style.display='';
banner.textContent = '✕ Could not load activity ('+apiError(status, json, 'load failed')+').';
box.innerHTML=''; return;
}
renderActivity(json);
}
function renderActivity(sum){
const box = document.getElementById('activity-admin');
if(!sum.event_count){ box.innerHTML = '<div class="note">No activity matches this filter.</div>'; return; }
const fmt = s => s ? wpFormatDateTime(s) : '—';
const bucket = (label, obj, take) => {
const entries = Object.entries(obj).sort((a,b)=> b[0].localeCompare(a[0])).slice(0, take);
if(!entries.length) return '';
return '<table class="kv" style="margin-top:8px"><caption style="text-align:left;font-weight:600;margin-bottom:4px">'+
uesc(label)+'</caption>'+entries.map(([k,v]) => '<tr><th>'+uesc(k)+'</th><td>'+v+' active user'+(v===1?'':'s')+'</td></tr>').join('')+
'</table>';
};
const perTool = Object.entries(sum.by_tool||{});
const toolTable = perTool.length ? '<table class="users"><thead><tr><th>Tool</th><th>Events</th></tr></thead><tbody>'+
perTool.map(([t,n]) => '<tr><td>'+uesc(t||'(login)')+'</td><td>'+n+'</td></tr>').join('')+'</tbody></table>' :
'<div class="note">No per-tool data.</div>';
const perUser = Object.entries(sum.per_user_last_active||{}).sort((a,b)=> String(b[1]).localeCompare(String(a[1])));
const userTable = perUser.length ? '<table class="users"><thead><tr><th>User</th><th>Last active</th></tr></thead><tbody>'+
perUser.map(([u,t]) => '<tr><td><strong>'+uesc(u)+'</strong></td><td style="color:var(--muted)">'+fmt(t)+'</td></tr>').join('')+
'</tbody></table>' : '<div class="note">No per-user data.</div>';
box.innerHTML =
'<div class="note">'+sum.event_count+' event'+(sum.event_count===1?'':'s')+' matched.</div>'+
'<div class="row" style="gap:var(--s4);flex-wrap:wrap;align-items:flex-start">'+
'<div>'+bucket('Active users by day', sum.active_users.by_day, 30)+'</div>'+
'<div>'+bucket('Active users by week', sum.active_users.by_week, 12)+'</div>'+
'<div>'+bucket('Active users by month', sum.active_users.by_month, 12)+'</div>'+
'</div>'+
'<h2 style="margin-top:16px">By tool</h2>'+toolTable+
'<h2 style="margin-top:16px">Per-user last active</h2>'+userTable;
}
async function exportActivity(sanitize){
const banner = document.getElementById('activity-export-banner');
banner.className='banner'; banner.style.display=''; banner.textContent='Preparing export…';
const q = _activityFilters();
if(sanitize) q.set('sanitize', 'true');
const { status, json } = await api('GET', '/api/usage/export?'+q.toString());
if(status!==200 || typeof json !== 'string'){
banner.className='banner bad';
banner.textContent = '✕ Export failed ('+apiError(status, json, 'export failed')+').';
return;
}
const blob = new Blob([json], { type:'text/csv' });
const a = document.createElement('a');
a.href = URL.createObjectURL(blob);
a.download = 'usage_export_'+(sanitize?'sanitized':'raw')+'_'+new Date().toISOString().slice(0,10)+'.csv';
document.body.appendChild(a); a.click(); a.remove();
setTimeout(() => URL.revokeObjectURL(a.href), 1000);
banner.className='banner ok';
banner.textContent = '✓ Downloaded the '+(sanitize?'sanitized':'raw')+' export.';
}
// ── notifications / email settings ──────────────────────────────────────────────
let _settings = {};
async function loadSettings(){
@@ -656,48 +753,6 @@ async function loadNotifications(){
'</tr>').join('')+'</tbody></table>';
}
// ── usage logs (read from this browser's localStorage) ──────────────────────────
// D5 / T7.10: the report for BOTH tools' recorded usage, in the one place an
// operator-facing readout belongs - behind the same admin gate as this whole
// page (gateByRole() below shows nothing else either). Data comes from
// wp-usage.js, the single implementation; the keys predate the move, so
// everything recorded before it is still here.
function loadUsage(){
const box = document.getElementById('usage-admin');
if(!box) return;
const tools = [
['Work package creator', WPUsage.KEYS.creator, 'wp-iwp-usage'],
['SOP wizard', WPUsage.KEYS.wizard, 'wp-suite-usage'],
];
let html = '';
tools.forEach(([label, key, prefix]) => {
const evs = (WPUsage.load(key).events) || [];
html += '<h2 style="margin-top:16px">' + uesc(label) + '</h2>';
if(!evs.length){
html += '<div class="note">No usage recorded in this browser yet.</div>';
return;
}
const byEvent = {}, sessions = new Set();
let first = evs[0].ts, last = evs[0].ts;
evs.forEach(e => {
byEvent[e.event] = (byEvent[e.event]||0)+1;
if(e.session) sessions.add(e.session);
if(e.ts < first) first = e.ts; if(e.ts > last) last = e.ts;
});
const fmt = v => v ? wpFormatDateTime(v) : '—';
html += '<table class="kv">'+
'<tr><th>Sessions</th><td>'+sessions.size+'</td></tr>'+
'<tr><th>Events</th><td>'+evs.length+'</td></tr>'+
'<tr><th>Range</th><td style="font-weight:600">'+fmt(first)+' → '+fmt(last)+'</td></tr></table>';
html += '<table class="users"><thead><tr><th>Event</th><th>Count</th></tr></thead><tbody>';
Object.keys(byEvent).sort().forEach(k => html += '<tr><td>'+uesc(k)+'</td><td>'+byEvent[k]+'</td></tr>');
html += '</tbody></table>';
html += '<div class="toolbar" style="margin-top:8px"><button onclick="WPUsage.download(WPUsage.KEYS.'+
(key === WPUsage.KEYS.creator ? 'creator' : 'wizard')+', ' + jsq(prefix) + ')">Download the full event log</button></div>';
});
box.innerHTML = html;
}
// ── access control: admins only ─────────────────────────────────────────────────
// auth-guard.js requires a login and sets window.WP_USER (firing 'wp-auth-ready').
// Show the console for admins; otherwise show the "Admins only" notice.

View File

@@ -60,62 +60,10 @@
.then(function () { window.location.replace('login.html'); });
};
// Change-password dialog (uses POST /api/auth/password, which requires the
// current password). Available from the top-right pill on any page.
window.wpChangePassword = function () {
if (document.getElementById('wp-pw-modal')) return;
var ov = document.createElement('div');
ov.id = 'wp-pw-modal';
ov.style.cssText = 'position:fixed;inset:0;background:rgba(20,30,50,.5);display:flex;align-items:center;' +
'justify-content:center;z-index:10002;padding:20px;font:14px/1.4 -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;';
var inp = 'width:100%;padding:9px 10px;margin-bottom:12px;border:1px solid var(--cds-border-strong);border-radius:4px;font-size:14px;';
var lbl = 'display:block;font-size:12px;color:var(--cds-text-secondary);margin-bottom:4px;';
ov.innerHTML =
'<div style="background:var(--cds-layer);color:var(--cds-text-primary);border-radius:10px;max-width:380px;width:100%;box-shadow:0 12px 40px rgba(20,30,50,.3);overflow:hidden;">' +
'<div style="padding:14px 18px;border-bottom:1px solid var(--cds-border-subtle);font-weight:700;">Change password</div>' +
'<div style="padding:16px 18px;">' +
'<div id="wp-pw-msg" style="display:none;font-size:12.5px;padding:8px 10px;border-radius:6px;margin-bottom:12px;"></div>' +
'<label style="' + lbl + '">Current password</label>' +
'<input id="wp-pw-cur" type="password" autocomplete="current-password" style="' + inp + '">' +
'<label style="' + lbl + '">New password (at least 12 characters)</label>' +
'<input id="wp-pw-new" type="password" autocomplete="new-password" style="' + inp + '">' +
'<label style="' + lbl + '">Confirm new password</label>' +
'<input id="wp-pw-new2" type="password" autocomplete="new-password" style="' + inp + 'margin-bottom:0;">' +
'</div>' +
'<div style="padding:12px 18px;border-top:1px solid var(--cds-border-subtle);display:flex;gap:8px;justify-content:flex-end;">' +
'<button type="button" id="wp-pw-cancel" style="padding:8px 14px;border:1px solid var(--cds-border-strong);background:var(--cds-layer);border-radius:6px;cursor:pointer;font-weight:600;">Cancel</button>' +
'<button type="button" id="wp-pw-save" style="padding:8px 14px;border:none;background:var(--cds-interactive-01);color:var(--cds-text-on-color);border-radius:6px;cursor:pointer;font-weight:600;">Update password</button>' +
'</div>' +
'</div>';
function close() { var m = document.getElementById('wp-pw-modal'); if (m) m.remove(); }
function msg(text, ok) {
var el = document.getElementById('wp-pw-msg');
el.style.display = 'block'; el.textContent = text;
el.style.background = ok ? 'var(--wp-status-success-bg)' : 'var(--wp-status-error-bg)'; el.style.color = ok ? 'var(--wp-status-success-text)' : 'var(--cds-support-error)';
}
ov.addEventListener('click', function (e) { if (e.target === ov) close(); });
document.body.appendChild(ov);
document.getElementById('wp-pw-cancel').onclick = close;
document.getElementById('wp-pw-cur').focus();
document.getElementById('wp-pw-save').onclick = function () {
var cur = document.getElementById('wp-pw-cur').value;
var n1 = document.getElementById('wp-pw-new').value;
var n2 = document.getElementById('wp-pw-new2').value;
if (!cur || !n1) { msg('Please fill in every field.', false); return; }
if (n1.length < 12) { msg('New password must be at least 12 characters.', false); return; }
if (n1 !== n2) { msg('New passwords do not match.', false); return; }
fetch('/api/auth/password', {
method: 'POST', headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ current_password: cur, new_password: n1 })
})
.then(function (r) { return r.json().catch(function () { return null; }).then(function (j) { return { ok: r.ok, status: r.status, j: j }; }); })
.then(function (res) {
if (res.ok) { msg('Password updated.', true); setTimeout(close, 1200); }
else { msg((res.j && res.j.detail) || ('Could not update (HTTP ' + res.status + ').'), false); }
})
.catch(function () { msg('Could not reach the server.', false); });
};
};
// window.wpChangePassword used to open a change-password dialog here. Removed in
// T10.4 (D15/D16): there is no local password to change anymore — identity is
// Okta's job. The "Password" item that called this is gone from wp-sidenav.js
// too.
// ── permissions helpers ────────────────────────────────────────────────────
// The server enforces all of this; these are for hiding controls the signed-in
@@ -171,21 +119,75 @@
// Admin, Users and Sign out from the navigation drawer, and being one unbreakable
// 412px run with an inline white-space:nowrap, it was what clipped the bar at 390px
// and cut "Sign out" in half — F2. wp-sidenav.js now carries all of it, including
// the two items that were only here: Language & time, and Password.
// the item that was only here: Language & time. (Password was the other one; T10.4
// removed it along with the rest of local auth — D15/D16.)
//
// Nothing replaces it. Every signed-in page mounts the drawer, so there is no page
// left that would need a floating fallback pill.
// ── CR-019: usage ping ───────────────────────────────────────────────────
// One page_open event per authenticated load, sent from exactly ONE place
// (here) rather than from each page's own script - the shared-chrome lesson
// S4 and the token-drift lesson S5 both taught this codebase the hard way.
// Fire-and-forget: never blocks reveal(), never retries, never surfaces an
// error to the person using the app - a missed usage ping is not something
// anyone here should notice happening.
var TOOL_BY_PAGE = {
'index.html': 'launcher',
'work-package-suite.html': 'wizard',
'wp-creation-index.html': 'creator',
'field.html': 'field_view',
'admin.html': 'admin',
'users.html': 'directory'
};
function pingUsage() {
var page = (location.pathname.split('/').pop() || 'index.html');
var tool = TOOL_BY_PAGE[page] || page.replace(/\.html$/, '');
try {
fetch('/api/usage/ping', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ tool: tool })
}).catch(function () {});
} catch (e) {}
}
function proceed(user) {
clearTimeout(safety);
window.WP_USER = user;
reveal();
if (window.WP_USER) {
window.wpFlags(); // start the feature-flag fetch; pages await it as needed
pingUsage();
try { document.dispatchEvent(new CustomEvent('wp-auth-ready', { detail: window.WP_USER })); } catch (e) {}
}
}
// D27. The offline sign-in window is the SERVER session, not a timer of the
// browser's own. /api/auth/me returns `session_expires_at` (the session token's
// exp), and that is what the cache keeps. Only a good answer from the server
// changes it: loading a page offline, or saving preferences, never extends it.
// (This replaced a fixed 12 hour window that slid forward on every page load and
// disagreed with AUTH_SESSION_HOURS.)
function readAuthCache() {
try { return JSON.parse(localStorage.getItem('wp_auth_cache') || 'null'); } catch (e) { return null; }
}
function writeAuthCache(user, expMs) {
try { if (user) localStorage.setItem('wp_auth_cache', JSON.stringify({ user: user, exp: expMs || 0, at: Date.now() })); } catch (e) {}
}
// For callers that refresh the cached user (the preferences dialog): the user
// changes, the end of the session does not.
window.wpCacheAuth = function (user) {
var c = readAuthCache();
writeAuthCache(user, c && c.exp);
};
// 'online' (a good answer from the server), 'offline' (opened from the cache
// before the session ended) or 'readqueue' (opened from the cache after it ended:
// cached data can be read and changes are queued, but nothing is sent until a
// good sign-in). The sync badge shows the one line for 'readqueue'.
window.WP_SESSION_MODE = 'online';
fetch('/api/auth/me', { headers: { 'Accept': 'application/json' } })
.then(function (r) {
if (r.status === 401 || r.status === 403) { try { localStorage.removeItem('wp_auth_cache'); } catch (e) {} goToLogin(); return; }
@@ -194,17 +196,26 @@
var user = data && data.user;
// Remember the last good auth so the PWA can open offline. The server is
// still the real gate; offline writes queue in the outbox until reconnect.
try { if (user) localStorage.setItem('wp_auth_cache', JSON.stringify({ user: user, at: Date.now() })); } catch (e) {}
var expMs = data && data.session_expires_at ? Date.parse(data.session_expires_at) : 0;
writeAuthCache(user, isNaN(expMs) ? 0 : expMs);
proceed(user);
});
})
.catch(function () {
// Offline / API unreachable: fall back to a recent cached auth if present,
// so the app (and the field view) still open without a network.
try {
var c = JSON.parse(localStorage.getItem('wp_auth_cache') || 'null');
if (c && c.user && (Date.now() - (c.at || 0)) < 12 * 3600 * 1000) { proceed(c.user); return; }
} catch (e) {}
// Offline / API unreachable: open from the cached sign-in so the app (and the
// field view) still work without a network. With no cache this device has
// never signed in, so there is nothing to open: go to the sign-in page.
var c = readAuthCache();
if (c && c.user) {
// Before the session ends: open as normal. After it (or when the cache has
// no end time, an older cache): read and queue. The page does NOT redirect,
// because login.html cannot reach Okta without a network.
var live = !!c.exp && Date.now() < c.exp;
window.WP_SESSION_MODE = live ? 'offline' : 'readqueue';
proceed(c.user);
try { document.dispatchEvent(new CustomEvent('wp-session-mode', { detail: window.WP_SESSION_MODE })); } catch (e) {}
return;
}
goToLogin();
});
})();

View File

@@ -31,34 +31,23 @@
margin-bottom: 1.5rem;
}
.brand img { height: 36px; width: auto; }
.brand .name { font-weight: 700; font-size: 0.95rem; color: var(--cds-text-primary); }
h1 { font-size: 1.5rem; margin-bottom: 0.25rem; }
.sub { color: var(--cds-text-secondary); font-size: 0.875rem; margin-bottom: 1.75rem; }
label { display: block; font-size: 0.75rem; color: var(--cds-text-secondary); margin-bottom: 0.375rem; }
.field { margin-bottom: 1.25rem; }
input[type=text], input[type=password] {
width: 100%;
padding: 0.75rem;
font-size: 1rem;
background: var(--cds-field);
border: none;
border-bottom: 1px solid var(--cds-border-strong);
outline: 2px solid transparent;
outline-offset: -2px;
}
input:focus { outline: 2px solid var(--cds-focus); background: var(--cds-field-hover); }
button {
.btn {
display: block;
width: 100%;
padding: 0.875rem 1rem;
font-size: 1rem;
font-weight: 600;
text-align: center;
text-decoration: none;
color: var(--cds-text-on-color);
background: var(--cds-button-primary);
border: none;
transition: background 0.15s;
}
button:hover:not(:disabled) { background: var(--cds-hover-primary); }
button:disabled { background: var(--cds-disabled-02); cursor: not-allowed; }
.btn:hover { background: var(--cds-hover-primary); }
.btn:focus-visible { outline: 2px solid var(--cds-focus); outline-offset: 2px; }
.error {
display: none;
background: var(--wp-status-error-bg);
@@ -69,7 +58,6 @@
margin-bottom: 1.25rem;
}
.error.show { display: block; }
.foot { margin-top: 1.5rem; font-size: 0.75rem; color: var(--cds-text-helper); text-align: center; }
.ok {
display: none;
background: var(--wp-status-success-bg);
@@ -80,15 +68,7 @@
margin-bottom: 1.25rem;
}
.ok.show { display: block; }
.note {
font-size: 0.8125rem; color: var(--cds-text-secondary);
background: var(--cds-layer-accent); border-left: 3px solid var(--cds-link-primary);
padding: 0.75rem; margin-bottom: 1.25rem;
}
.hint { font-size: 0.75rem; color: var(--cds-text-helper); margin-top: -0.75rem; margin-bottom: 1.25rem; }
a.link { color: var(--cds-link-primary); text-decoration: none; font-size: 0.8125rem; }
a.link:hover { text-decoration: underline; }
.center { text-align: center; margin-top: 1.25rem; }
.foot { margin-top: 1.5rem; font-size: 0.75rem; color: var(--cds-text-helper); text-align: center; }
</style>
</head>
<body>
@@ -99,61 +79,10 @@
<div id="error" class="error" role="alert"></div>
<div id="ok" class="ok" role="status"></div>
<!-- SIGN IN -->
<section id="view-login">
<h1>Sign in</h1>
<p class="sub">Work Package Suite</p>
<form id="login-form" autocomplete="on">
<div class="field">
<label for="username">Username</label>
<input id="username" name="username" type="text" autocomplete="username" autofocus required>
</div>
<div class="field">
<label for="password">Password</label>
<input id="password" name="password" type="password" autocomplete="current-password" required>
</div>
<button id="submit" type="submit">Sign in</button>
</form>
<p class="center"><a href="#" id="forgot-link" class="link">Forgot password?</a></p>
</section>
<!-- FORGOT PASSWORD (email reset) -->
<section id="view-forgot" style="display:none">
<h1>Reset password</h1>
<p class="sub">We'll email you a link to set a new one.</p>
<div id="forgot-unavailable" class="note" style="display:none">
Password reset by email isn't switched on yet. Contact your project admin and
they'll set a new password for you. Once you're signed in you can change it
yourself from the menu in the top-right corner.
</div>
<form id="forgot-form" autocomplete="on">
<div class="field">
<label for="forgot-username">Username or email</label>
<input id="forgot-username" type="text" autocomplete="username" required>
</div>
<button id="forgot-submit" type="submit">Email me a reset link</button>
</form>
<p class="center"><a href="#" id="back-to-login" class="link">← Back to sign in</a></p>
</section>
<!-- SET A NEW PASSWORD (arrived from the emailed link) -->
<section id="view-reset" style="display:none">
<h1>Set a new password</h1>
<p class="sub">Choose a password you don't use anywhere else.</p>
<form id="reset-form" autocomplete="on">
<div class="field">
<label for="new-password">New password</label>
<input id="new-password" type="password" autocomplete="new-password" autofocus required>
</div>
<div class="hint">At least 12 characters.</div>
<div class="field">
<label for="new-password2">Confirm new password</label>
<input id="new-password2" type="password" autocomplete="new-password" required>
</div>
<button id="reset-submit" type="submit">Set password &amp; sign in</button>
</form>
<p class="center"><a href="#" id="reset-to-login" class="link">← Back to sign in</a></p>
</section>
<h1>Sign in</h1>
<p class="sub">Work Package Suite uses your organization's Okta sign-in. Select the
button below and follow the prompts there.</p>
<a id="okta-signin" class="btn" href="/api/auth/okta/login" autofocus>Sign in with Okta</a>
<p class="foot">Authorized use only · BTG / Pilot</p>
</main>

View File

@@ -1,26 +1,16 @@
/* Login page logic for the Work Package Suite.
Three views on one page:
• sign in posts to /api/auth/login. On success the server sets an
HttpOnly session cookie (not readable here — that's the
point) and we redirect to ?next= or the home page.
• forgot password posts to /api/auth/forgot-password, which emails a
single-use link. Only offered when the server reports
email is actually configured (/api/auth/reset-available);
otherwise we say to ask an admin.
• set a new password shown when the page is opened as login.html?reset=<token>
from that email. Posts to /api/auth/reset-password.
The reset token stays in the URL only until it's used; on success we strip it
from the address bar so it isn't left in history or copied out of the bar. */
One action: sign in with Okta. There is no local password anymore (D15/D16,
T10.4) — this page's only job is building the link to /api/auth/okta/login
(carrying ?next=, if there was one) and showing a plain-language message for
the failure states server/app.py's okta_callback() sends back here (T10.5). */
(function () {
'use strict';
var errorBox = document.getElementById('error');
var okBox = document.getElementById('ok');
var signinLink = document.getElementById('okta-signin');
function show(el) { if (el) el.style.display = ''; }
function hide(el) { if (el) el.style.display = 'none'; }
function byId(id) { return document.getElementById(id); }
function showError(msg) {
@@ -28,188 +18,38 @@
errorBox.textContent = msg;
errorBox.classList.add('show');
}
function showOk(msg) {
errorBox.classList.remove('show');
okBox.textContent = msg;
okBox.classList.add('show');
}
function clearBanners() {
errorBox.classList.remove('show');
okBox.classList.remove('show');
}
// Where to go after signing in: the ?next= param if it's a safe same-site
// path, otherwise the home page. (Reject absolute/scheme URLs to avoid an
// open-redirect.)
function nextTarget() {
// Same-site path only — mirrors the check server/app.py's _safe_next_path()
// makes again on the way back, so a crafted ?next= can't become an open
// redirect even if this client-side check were somehow bypassed.
function safeNext() {
try {
var next = new URLSearchParams(location.search).get('next') || '';
if (next && next.charAt(0) === '/' && next.charAt(1) !== '/') return next;
} catch (e) {}
return 'index.html';
return '';
}
function resetToken() {
try { return new URLSearchParams(location.search).get('reset') || ''; } catch (e) { return ''; }
if (signinLink) {
var next = safeNext();
if (next) signinLink.href = '/api/auth/okta/login?next=' + encodeURIComponent(next);
}
function postJson(url, payload) {
return fetch(url, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload)
}).then(function (r) {
return r.json().catch(function () { return null; }).then(function (j) {
return { status: r.status, ok: r.ok, json: j };
});
});
}
var ERROR_MESSAGES = {
disabled: 'Your account has been disabled. Contact an administrator.',
cancelled: 'Sign-in was not completed. Select the button below to try again.'
};
function detail(res, fallback) {
var d = res && res.json && res.json.detail;
return (typeof d === 'string' && d) ? d : fallback;
}
function view(which) {
clearBanners();
['login', 'forgot', 'reset'].forEach(function (v) {
(which === v ? show : hide)(byId('view-' + v));
});
}
// ── sign in ────────────────────────────────────────────────────────────────
var form = byId('login-form');
var submitBtn = byId('submit');
// Guarded because a cached older login.html may not have the reset views; an
// unguarded addEventListener on null would break sign-in itself.
if (!form || !submitBtn) return;
form.addEventListener('submit', function (e) {
e.preventDefault();
clearBanners();
var username = byId('username').value.trim();
var password = byId('password').value;
if (!username || !password) { showError('Enter your username and password.'); return; }
submitBtn.disabled = true;
submitBtn.textContent = 'Signing in…';
postJson('/api/auth/login', { username: username, password: password })
.then(function (res) {
if (res.ok) { location.replace(nextTarget()); return; }
if (res.status === 401) showError('Invalid username or password.');
else if (res.status === 403) showError(detail(res, 'Your account is disabled.'));
else if (res.status === 429) showError(detail(res, 'Too many failed attempts. Try again later.'));
else showError(detail(res, 'Sign-in failed (HTTP ' + res.status + ').'));
submitBtn.disabled = false;
submitBtn.textContent = 'Sign in';
})
.catch(function () {
showError('Could not reach the server. Check your connection and try again.');
submitBtn.disabled = false;
submitBtn.textContent = 'Sign in';
});
});
// ── forgot password ────────────────────────────────────────────────────────
var resetAvailable = null; // null = not checked yet
function checkResetAvailable() {
if (resetAvailable !== null) return Promise.resolve(resetAvailable);
return fetch('/api/auth/reset-available')
.then(function (r) { return r.ok ? r.json() : null; })
.then(function (j) { resetAvailable = !!(j && j.enabled); return resetAvailable; })
.catch(function () { resetAvailable = false; return false; });
}
(byId('forgot-link') || {addEventListener: function(){}}).addEventListener('click', function (e) {
e.preventDefault();
view('forgot');
// Prefill from the sign-in box so nobody types their username twice.
var u = byId('username').value.trim();
if (u) byId('forgot-username').value = u;
checkResetAvailable().then(function (enabled) {
// With email off there's nothing to submit — say so and hide the form.
(enabled ? hide : show)(byId('forgot-unavailable'));
(enabled ? show : hide)(byId('forgot-form'));
if (enabled) byId('forgot-username').focus();
});
});
(byId('back-to-login') || {addEventListener: function(){}}).addEventListener('click', function (e) {
e.preventDefault();
view('login');
});
var forgotForm = byId('forgot-form') || document.createElement('form');
var forgotBtn = byId('forgot-submit') || document.createElement('button');
forgotForm.addEventListener('submit', function (e) {
e.preventDefault();
clearBanners();
var who = byId('forgot-username').value.trim();
if (!who) { showError('Enter your username or email.'); return; }
forgotBtn.disabled = true;
forgotBtn.textContent = 'Sending…';
postJson('/api/auth/forgot-password', { username: who })
.then(function (res) {
if (res.status === 503) {
showError(detail(res, "Password reset by email isn't available. Ask an administrator."));
} else if (res.ok) {
// Deliberately the same message whether or not the account exists.
showOk('If that account exists, a reset link is on its way. The link expires in an hour.');
hide(forgotForm);
} else {
showError(detail(res, 'Could not send the reset email (HTTP ' + res.status + ').'));
}
forgotBtn.disabled = false;
forgotBtn.textContent = 'Email me a reset link';
})
.catch(function () {
showError('Could not reach the server. Check your connection and try again.');
forgotBtn.disabled = false;
forgotBtn.textContent = 'Email me a reset link';
});
});
// ── set a new password (from the emailed link) ──────────────────────────────
(byId('reset-to-login') || {addEventListener: function(){}}).addEventListener('click', function (e) {
e.preventDefault();
view('login');
});
var resetForm = byId('reset-form') || document.createElement('form');
var resetBtn = byId('reset-submit') || document.createElement('button');
resetForm.addEventListener('submit', function (e) {
e.preventDefault();
clearBanners();
var token = resetToken();
var pw = byId('new-password').value;
var pw2 = byId('new-password2').value;
if (!token) { showError('This reset link is incomplete. Request a new one.'); return; }
if (pw !== pw2) { showError('The two passwords do not match.'); return; }
if (pw.length < 12) { showError('Password must be at least 12 characters.'); return; }
resetBtn.disabled = true;
resetBtn.textContent = 'Saving…';
postJson('/api/auth/reset-password', { token: token, new_password: pw })
.then(function (res) {
if (res.ok) {
// Take the token out of the URL before anything else — it's spent.
try { history.replaceState(null, '', 'login.html'); } catch (err) {}
view('login');
showOk('Password updated. Sign in with your new password.');
byId('username').focus();
return;
}
showError(detail(res, 'Could not set your password (HTTP ' + res.status + ').'));
resetBtn.disabled = false;
resetBtn.textContent = 'Set password & sign in';
})
.catch(function () {
showError('Could not reach the server. Check your connection and try again.');
resetBtn.disabled = false;
resetBtn.textContent = 'Set password & sign in';
});
});
// Arriving from the reset email opens straight into the new-password view.
if (resetToken()) view('reset');
(function showErrorFromQuery() {
try {
var code = new URLSearchParams(location.search).get('error') || '';
if (!code) return;
showError(ERROR_MESSAGES[code] || 'Sign-in was not completed. Select the button below to try again.');
// Out of the address bar once shown — an error code has no reason to
// survive a refresh or get copied along with the link.
var url = new URL(location.href);
url.searchParams.delete('error');
history.replaceState(null, '', url.pathname + url.search);
} catch (e) {}
})();
})();

View File

@@ -245,25 +245,64 @@
// local cache still updates immediately, so rendering never waits on the network.
var OUTBOX_KEY = 'wp_sync_outbox_v1';
var _flushTimer = null, _backoff = 0, _flushing = false;
// D26. `_held` is set when the server answers 401: the session ended, so the
// queue waits for a good sign-in. It is cleared ONLY by `wp-auth-ready` (a page
// load with a good session check), never by the online event, the timer or tab
// focus, because none of those prove the session is back.
var _held = false;
// D26. Changes the device could not store (localStorage full) stay here, in page
// memory, and are still sent. They are lost if the page closes, so the badge says
// they are not saved on this device. They are never dropped without a word.
var _mem = [];
var _deviceFull = false;
function qRead() { try { return JSON.parse(localStorage.getItem(OUTBOX_KEY) || '[]') || []; } catch (e) { return []; } }
function qWrite(list) { try { localStorage.setItem(OUTBOX_KEY, JSON.stringify(list)); } catch (e) {} }
// Returns true when the list is stored. A storage error used to be swallowed here,
// so a full device lost the change and nobody knew (D26, fault 2).
function qWrite(list) {
try { localStorage.setItem(OUTBOX_KEY, JSON.stringify(list)); return true; }
catch (e) { return false; }
}
// Stored ops plus any held only in memory, stored ones first (send order).
function qAll() {
var q = qRead();
if (!_mem.length) return q;
var ids = {};
q.forEach(function (o) { ids[o.opId] = true; });
return q.concat(_mem.filter(function (o) { return !ids[o.opId]; }));
}
// Remove one op everywhere it can be held.
function qDrop(opId) {
_mem = _mem.filter(function (o) { return o.opId !== opId; });
qWrite(qRead().filter(function (o) { return o.opId !== opId; }));
}
function readQueueMode() { try { return window.WP_SESSION_MODE === 'readqueue'; } catch (e) { return false; } }
function sameUser(a, b) { return String(a || '').toLowerCase() === String(b || '').toLowerCase(); }
// Append an op, coalescing by (kind,key) so only the latest write per entity is
// queued. A delete supersedes any pending upsert for the same id.
// queued. A delete supersedes any pending upsert for the same id. Returns true
// when the change is stored on this device, false when it is only in memory.
function enqueue(op) {
var q = qRead();
if (op.kind === 'wp-del') {
q = q.filter(function (o) { return !(o.key === op.key && (o.kind === 'wp' || o.kind === 'wp-del')); });
} else {
q = q.filter(function (o) { return !(o.kind === op.kind && o.key === op.key); });
}
var supersedes = (op.kind === 'wp-del')
? function (o) { return o.key === op.key && (o.kind === 'wp' || o.kind === 'wp-del'); }
: function (o) { return o.kind === op.kind && o.key === op.key; };
var q = qRead().filter(function (o) { return !supersedes(o); });
_mem = _mem.filter(function (o) { return !supersedes(o); });
op.opId = op.kind + ':' + op.key + ':' + Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
op.tries = 0;
op.owner = currentUser(); // D26: sent only when this person is signed in
q.push(op);
qWrite(q);
var stored = qWrite(q);
if (stored) {
// Room again: bring anything held in memory onto the device.
if (_mem.length && qWrite(q.concat(_mem))) _mem = [];
_deviceFull = _mem.length > 0;
} else {
_mem.push(op); _deviceFull = true;
}
notifySync();
scheduleFlush(0);
return stored;
}
function opRequest(op) {
@@ -275,41 +314,65 @@
});
}
// Apply `fn` to the op with this id, wherever it is held (device or memory).
function patchOp(opId, fn) {
var q = qRead(), hit = false;
for (var i = 0; i < q.length; i++) { if (q[i].opId === opId) { fn(q[i]); hit = true; break; } }
if (hit) qWrite(q);
for (var j = 0; j < _mem.length; j++) { if (_mem[j].opId === opId) { fn(_mem[j]); break; } }
}
function bumpTries(opId, err) {
var q = qRead();
for (var i = 0; i < q.length; i++) { if (q[i].opId === opId) { q[i].tries = (q[i].tries || 0) + 1; q[i].lastErr = err; break; } }
qWrite(q);
patchOp(opId, function (o) { o.tries = (o.tries || 0) + 1; o.lastErr = err; });
}
// Permanently-failed op (a 4xx client error) — keep it for visibility but stop
// retrying, so a rejected write can't loop forever. `err` is the server's own
// explanation when it sent one; it is what the sync badge shows the user.
function markDead(opId, err) {
var q = qRead();
for (var i = 0; i < q.length; i++) { if (q[i].opId === opId) { q[i].dead = true; q[i].lastErr = err; break; } }
qWrite(q);
patchOp(opId, function (o) { o.dead = true; o.lastErr = err; });
}
// Attempt every live op; successes are removed, 4xx client errors are marked
// dead (won't succeed on retry), transient failures (429/5xx/network) stay queued.
// True when this op is waiting for another person to sign in (D26). An op with no
// owner (queued before the sign-in check finished) can be sent by anyone, which is
// what every op did before owners existed.
function foreignOp(o) {
var me = currentUser();
return !!o.owner && !sameUser(o.owner, me);
}
function liveOps() { return qAll().filter(function (o) { return !o.dead; }); }
function sendableOps() { return liveOps().filter(function (o) { return !foreignOp(o); }); }
// Attempt every live op that belongs to the signed-in person; successes are
// removed. A 401 HOLDS the queue (D26): the session ended, which says nothing
// about the changes, so nothing is marked dead and no try is counted. A 403 or
// other 4xx is marked dead (it will not succeed on retry); transient failures
// (429/5xx/network) stay queued.
function flush() {
if (_flushing) return Promise.resolve();
var q = qRead().filter(function (o) { return !o.dead; });
// D27: opened offline after the session ended (read and queue). Changes are kept
// and wait; nothing is sent until a page load gets a good answer from the server.
if (_held || readQueueMode()) { notifySync(); return Promise.resolve(); }
var q = sendableOps();
if (!q.length) { notifySync(); return Promise.resolve(); }
_flushing = true; notifySync();
var chain = Promise.resolve(), anyFail = false;
var chain = Promise.resolve(), anyFail = false, halted = false;
q.forEach(function (op) {
chain = chain.then(function () {
if (halted) return; // a 401 stops the run; later ops keep their place
return opRequest(op).then(function (r) {
var status = r ? r.status : 0;
var done = r && (r.ok || (op.kind === 'wp-del' && status === 404)); // 404 on delete = already gone
if (done) { qWrite(qRead().filter(function (o) { return o.opId !== op.opId; })); }
if (done) { qDrop(op.opId); }
else if (status === 401) { halted = true; _held = true; }
else if (status >= 400 && status < 500 && status !== 429) {
// Refused once, refused forever — so the only useful thing left is the
// reason. A 409 here is the archived-project gate, whose detail tells
// the user the project is read-only and how to get it unarchived; a
// bare "HTTP 409" would leave them staring at a change that vanished.
return r.json().catch(function () { return null; }).then(function (j) {
var why = (j && typeof j.detail === 'string' && j.detail) || ('HTTP ' + status);
var detail = (j && typeof j.detail === 'string' && j.detail) || '';
var why = status === 403
? 'You no longer have access to this project.' + (detail ? ' (' + detail + ')' : '')
: (detail || ('HTTP ' + status));
markDead(op.opId, why);
});
}
@@ -320,7 +383,8 @@
return chain.then(function () {
_flushing = false;
notifySync();
if (qRead().filter(function (o) { return !o.dead; }).length) {
if (_held) return; // wait for wp-auth-ready; no timer retries a dead session
if (sendableOps().length) {
_backoff = anyFail ? Math.min((_backoff || 5000) * 2, 60000) : 0;
scheduleFlush(_backoff || 15000);
} else { _backoff = 0; }
@@ -336,14 +400,21 @@
// `failed` stays the total not-getting-through count (what listeners already
// read); `dead` splits out the ops the server has permanently refused, with the
// first reason it gave, because those two states need different words.
// D26 adds: `held` (the session ended; the queue waits for a sign-in), `others`
// and `otherOwner` (changes that belong to someone else, waiting for them),
// `deviceFull` and `unsaved` (changes that exist only in page memory).
function syncCounts() {
var q = qRead(), pending = 0, failed = 0, dead = 0, reason = '';
var q = qAll(), pending = 0, failed = 0, dead = 0, reason = '', others = 0, otherOwner = '';
for (var i = 0; i < q.length; i++) {
if (q[i].dead) { dead++; if (!reason && q[i].lastErr) reason = String(q[i].lastErr); }
else if (foreignOp(q[i])) { others++; if (!otherOwner) otherOwner = String(q[i].owner); }
else if ((q[i].tries || 0) >= 3) failed++;
else pending++;
}
return { pending: pending, failed: failed + dead, dead: dead, reason: reason, syncing: _flushing };
return {
pending: pending, failed: failed + dead, dead: dead, reason: reason, syncing: _flushing,
held: _held, others: others, otherOwner: otherOwner, deviceFull: _deviceFull, unsaved: _mem.length
};
}
ProjectData.syncStatus = syncCounts;
function notifySync() {
@@ -352,63 +423,212 @@
renderSyncBadge(c);
}
// Tiny sync indicator (bottom-left). This was gated on being the top-level
// window so it was not drawn twice - once by the suite page and again inside
// the embedded creator. B7/T7.1 dissolved that frame, so there is one document
// and one badge. The 'storage' listener below stays: it is what keeps two
// TABS in step, which is a different thing and still happens.
var _badgeHideTimer = null;
// The sync badge (D26, BL-061). It reports the OUTBOX: whether saved records have
// reached the project. This was gated on being the top-level window so it was not
// drawn twice (the suite page and the embedded creator); B7/T7.1 dissolved that
// frame, so there is one document and one badge. The 'storage' listener below
// stays: it is what keeps two TABS in step, which is a different thing.
var _badgeHideTimer = null, _badgePlaceTimer = null, _hadWork = false;
// BL-011 (fixed at T9.9): the badge used to mount on the FIRST SYNC EVENT,
// which is async, so the three fixed overlays on the SOP page landed in a
// different DOM order run to run and every index-keyed comparison saw
// phantom diffs. Mounting the (hidden) holder at DOMContentLoaded puts the
// three in script order, deterministically.
document.addEventListener('DOMContentLoaded', function () { renderSyncBadge(null); });
// BL-061: the console pages (Admin, User Directory) never queue project work, and
// the badge used to sit over their bottom-right buttons. They opt out with
// data-wp-no-sync-badge on <body>.
function badgeExempt() { return !!(document.body && document.body.hasAttribute('data-wp-no-sync-badge')); }
// Discard the changes the project refused. The person has read the reason and
// chose to dismiss it; nothing else ever removes a queued change by itself.
function dismissRejected() {
_mem = _mem.filter(function (o) { return !o.dead; });
qWrite(qRead().filter(function (o) { return !o.dead; }));
notifySync();
}
function signInUrl() {
return 'login.html?next=' + encodeURIComponent(location.pathname + location.search);
}
// One place decides what the badge says. B5: every string names the PROJECT, so it
// cannot be read as the draft indicator (WPAutosave.mountIndicator), which speaks
// for the form. tone is one of neutral, ok, warn, error.
function badgeModel(c) {
var n;
if (c.deviceFull) {
n = c.unsaved;
return { tone: 'error', text: '✕ ' + n + ' change' + (n === 1 ? ' is' : 's are') + ' not saved on this device. Keep this page open until it is sent to the project.' };
}
if (readQueueMode()) {
return { tone: 'warn', text: 'Working offline. Sign in again when you have a signal to send your changes to the project.', signIn: true };
}
if (c.held) {
return { tone: 'warn', text: '⚠ Sign in again to send your changes to the project. They are kept on this device.', signIn: true };
}
if (c.dead) {
return { tone: 'error', text: '✕ ' + c.dead + ' change' + (c.dead === 1 ? '' : 's') + ' rejected by the project. Not saved.', reason: c.reason, dismiss: true };
}
if (c.failed) {
return { tone: 'warn', text: '⚠ ' + c.failed + ' change' + (c.failed === 1 ? '' : 's') + ' not yet sent to the project. Retrying.' };
}
if (c.pending) {
return { tone: 'neutral', text: '↻ Sending ' + c.pending + ' change' + (c.pending === 1 ? '' : 's') + ' to the project…' };
}
if (c.others) {
return { tone: 'warn', text: '⚠ ' + c.others + ' change' + (c.others === 1 ? ' belongs' : 's belong') + ' to ' + c.otherOwner + '. ' + (c.others === 1 ? 'It goes' : 'They go') + ' to the project when ' + c.otherOwner + ' signs in.' };
}
// Nothing to report. "Everything sent" follows real work only: on a page that
// never queued anything it is noise that sits over the controls (BL-061).
if (!_hadWork) return null;
return { tone: 'ok', text: '✓ Everything sent to the project', autoHide: true };
}
var TONES = {
neutral: ['var(--cds-text-secondary)', 'var(--cds-border-subtle)', 'var(--cds-layer)'],
ok: ['var(--wp-status-success-text)', 'var(--wp-status-success-border-a)', 'var(--wp-status-success-bg)'],
warn: ['var(--wp-status-warning-text)', 'var(--cds-support-warning)', 'var(--wp-status-warning-bg)'],
error: ['var(--wp-status-error-text)', 'var(--wp-status-error-border-a)', 'var(--wp-status-error-bg)']
};
function ensureBadgeStyle() {
if (document.getElementById('wp-sync-badge-style')) return;
var st = document.createElement('style');
st.id = 'wp-sync-badge-style';
// Controls are real <a> and <button> elements: reachable by keyboard and touch,
// at least 44px high, with a focus ring from the shared focus token.
st.textContent =
'#wp-sync-badge{max-width:min(420px,calc(100vw - 24px));box-sizing:border-box}' +
'@media (max-width:480px){#wp-sync-badge{max-width:min(300px,calc(100vw - 24px))}}' +
'#wp-sync-badge .wp-sb-msg{display:flex;flex-direction:column;gap:2px;min-width:0}' +
'#wp-sync-badge .wp-sb-reason{font-weight:400}' +
'#wp-sync-badge .wp-sb-ctl{display:inline-flex;align-items:center;justify-content:center;box-sizing:border-box;' +
'min-width:44px;min-height:44px;padding:0 10px;margin:-6px -12px -6px -4px;border:0;background:transparent;color:inherit;' +
'font-family:inherit;font-weight:600;font-size:12px;line-height:1.3;text-decoration:underline;cursor:pointer}' +
'#wp-sync-badge .wp-sb-ctl:focus-visible{outline:2px solid var(--cds-focus);outline-offset:-2px}';
(document.head || document.documentElement).appendChild(st);
}
// BL-061: keep the badge clear of page controls. Measure every visible control,
// then put the badge in the first free spot: the four corners first, then any gap
// on the screen that is big enough, scanning from the bottom up. Page headers and
// bottom bars fill the width at 390px, so fixed corners alone cannot clear them.
// If no spot is free, take the one that covers the fewest controls.
var CONTROLS = 'a[href],button,input,select,textarea,summary,[role="button"],[tabindex]:not([tabindex="-1"])';
function controlRects(el) {
var out = [], list = document.querySelectorAll(CONTROLS);
for (var i = 0; i < list.length; i++) {
var o = list[i];
if (o === el || el.contains(o)) continue;
var b = o.getBoundingClientRect();
if (!b.width || !b.height || !o.getClientRects().length) continue;
var cs = window.getComputedStyle(o);
if (cs.visibility === 'hidden' || cs.display === 'none') continue;
out.push(b);
}
return out;
}
function hitCount(rects, x, y, w, h) {
var n = 0;
for (var i = 0; i < rects.length; i++) {
var b = rects[i];
if (b.left < x + w && b.right > x && b.top < y + h && b.bottom > y) n++;
}
return n;
}
function placeBadge(el) {
if (el.style.display === 'none') return;
var vw = document.documentElement.clientWidth, vh = window.innerHeight;
// Measure at the left edge, where the box has all the room it will ever have,
// then pin that width: a box measured near the right edge wraps and grows.
el.style.width = ''; el.style.right = 'auto'; el.style.bottom = 'auto';
el.style.left = '0px'; el.style.top = '0px';
var r = el.getBoundingClientRect(), w = Math.ceil(r.width), h = Math.ceil(r.height), m = 12;
el.style.width = w + 'px';
var rects = controlRects(el);
var spots = [
[vw - w - m, vh - h - m], [m, vh - h - m], [vw - w - m, m], [m, m]
];
// Then every gap, bottom to top, right to left, in 8px steps.
for (var y = vh - h - m; y >= m; y -= 8) {
for (var x = vw - w - m; x >= m; x -= 8) spots.push([x, y]);
}
var best = spots[0], bestN = Infinity;
for (var i = 0; i < spots.length; i++) {
var n = hitCount(rects, spots[i][0], spots[i][1], w, h);
if (n < bestN) { bestN = n; best = spots[i]; }
if (n === 0) break;
}
el.style.right = 'auto'; el.style.bottom = 'auto';
el.style.left = Math.max(0, Math.round(best[0])) + 'px';
el.style.top = Math.max(0, Math.round(best[1])) + 'px';
}
function renderSyncBadge(c) {
if (!document.body) return;
var el = document.getElementById('wp-sync-badge');
if (!el) {
ensureBadgeStyle();
el = document.createElement('div');
el.id = 'wp-sync-badge';
// S10. Polite: this reports background syncing, and interrupting someone to
// say a queue drained is exactly the noise that gets aria-live turned off.
el.setAttribute('role', 'status');
el.style.cssText = 'position:fixed;right:12px;bottom:12px;z-index:9998;pointer-events:none;display:none;align-items:center;gap:7px;' +
el.style.cssText = 'position:fixed;right:12px;bottom:12px;z-index:9998;pointer-events:none;display:none;align-items:center;gap:12px;' +
'font:500 12px/1.3 "IBM Plex Sans",-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;' +
'padding:6px 12px;border:1px solid var(--cds-border-subtle);background:var(--cds-layer);color:var(--cds-text-secondary);box-shadow:0 1px 4px rgba(0,0,0,.12);transition:opacity .2s;';
document.body.appendChild(el);
window.addEventListener('resize', function () { placeBadge(el); });
}
if (!c) return; // the eager DOMContentLoaded mount: holder only, no state yet
if (_badgeHideTimer) { clearTimeout(_badgeHideTimer); _badgeHideTimer = null; }
// A dead op is a refusal, not a hiccup — "retrying" would be a lie, and the
// reason is the only thing that tells the user what to do (e.g. the project is
// archived). Stack it under the headline; the badge never hides in this state.
el.style.flexDirection = c.dead ? 'column' : 'row';
el.style.alignItems = c.dead ? 'flex-start' : 'center';
el.style.maxWidth = c.dead ? 'min(340px, calc(100vw - 32px))' : 'none';
// B5. This badge reports the OUTBOX — whether saved records have reached the
// project — and it used to say "✓ All changes saved", which is what a draft
// autosave says. So the app was already making the promise B5 says it does not
// keep: the badge went green when the queue emptied, whether or not anything in
// the form had been saved at all.
//
// Every string here now names the project explicitly. The draft indicator
// (WPAutosave.mountIndicator) is the one that speaks for the form, and the two
// can no longer be read as each other.
if (c.dead) {
el.innerHTML = '<span>✕ ' + c.dead + ' change' + (c.dead === 1 ? '' : 's') + ' rejected by the project — not saved</span>' +
(c.reason ? '<span style="font-weight:400">' + esc(c.reason) + '</span>' : '');
el.style.color = 'var(--wp-status-error-text)'; el.style.borderColor = 'var(--wp-status-error-border-a)'; el.style.background = 'var(--wp-status-error-bg)'; el.style.display = 'inline-flex';
} else if (c.failed) {
el.textContent = '⚠ ' + c.failed + ' change' + (c.failed === 1 ? '' : 's') + ' not yet sent to the project — retrying';
el.style.color = 'var(--wp-status-warning-text)'; el.style.borderColor = 'var(--cds-support-warning)'; el.style.background = 'var(--wp-status-warning-bg)'; el.style.display = 'inline-flex';
} else if (c.pending) {
el.textContent = '↻ Sending ' + c.pending + ' change' + (c.pending === 1 ? '' : 's') + ' to the project…';
el.style.color = 'var(--cds-text-secondary)'; el.style.borderColor = 'var(--cds-border-subtle)'; el.style.background = 'var(--cds-layer)'; el.style.display = 'inline-flex';
} else {
el.textContent = '✓ Everything sent to the project';
el.style.color = 'var(--wp-status-success-text)'; el.style.borderColor = 'var(--wp-status-success-border-a)'; el.style.background = 'var(--wp-status-success-bg)'; el.style.display = 'inline-flex';
if (_badgePlaceTimer) { clearInterval(_badgePlaceTimer); _badgePlaceTimer = null; }
if (c.pending || c.failed || c.held || c.others || c.deviceFull) _hadWork = true;
var m = badgeExempt() ? null : badgeModel(c);
if (!m) { el.style.display = 'none'; el.style.pointerEvents = 'none'; return; }
var t = TONES[m.tone] || TONES.neutral;
el.style.color = t[0]; el.style.borderColor = t[1]; el.style.background = t[2];
el.style.pointerEvents = (m.signIn || m.dismiss) ? 'auto' : 'none';
// Rebuild the contents. The container keeps role="status", so a change of text
// is announced; the controls inside it are ordinary focusable elements.
while (el.firstChild) el.removeChild(el.firstChild);
var msg = document.createElement('span');
msg.className = 'wp-sb-msg';
var head = document.createElement('span');
head.textContent = m.text;
msg.appendChild(head);
if (m.reason) {
var why = document.createElement('span');
why.className = 'wp-sb-reason';
why.textContent = String(m.reason);
msg.appendChild(why);
}
el.appendChild(msg);
if (m.signIn) {
var a = document.createElement('a');
a.className = 'wp-sb-ctl';
a.href = signInUrl();
a.textContent = 'Sign in';
el.appendChild(a);
}
if (m.dismiss) {
var d = document.createElement('button');
d.type = 'button';
d.className = 'wp-sb-ctl';
d.textContent = 'Dismiss';
d.addEventListener('click', dismissRejected);
el.appendChild(d);
}
el.style.display = 'inline-flex';
placeBadge(el);
if (m.autoHide) {
_hadWork = false; // the next "sent" needs new work
_badgeHideTimer = setTimeout(function () { if (el) el.style.display = 'none'; }, 1800);
} else {
// A state that stays: re-check the spot now and then, since the page under it changes.
_badgePlaceTimer = setInterval(function () { placeBadge(el); }, 2000);
}
}
@@ -418,7 +638,12 @@
window.addEventListener('online', function () { _backoff = 0; scheduleFlush(0); });
window.addEventListener('storage', function (e) { if (e.key === OUTBOX_KEY) { notifySync(); scheduleFlush(0); } });
document.addEventListener('visibilitychange', function () { if (!document.hidden) scheduleFlush(0); });
setInterval(function () { if (qRead().filter(function (o) { return !o.dead; }).length) scheduleFlush(0); }, 20000);
setInterval(function () { if (sendableOps().length) scheduleFlush(0); }, 20000);
// D26: the one thing that releases a held queue. auth-guard fires this after a
// good /api/auth/me (or the offline cache), and the next flush finds out for
// itself whether the session is really good: a 401 holds the queue again.
document.addEventListener('wp-session-mode', function () { notifySync(); });
document.addEventListener('wp-auth-ready', function () { _held = false; _backoff = 0; notifySync(); scheduleFlush(0); });
} catch (e) {}
if (document.readyState === 'loading') { document.addEventListener('DOMContentLoaded', function () { notifySync(); scheduleFlush(0); }); }
else { setTimeout(function () { notifySync(); scheduleFlush(0); }, 0); }
@@ -428,7 +653,7 @@
// project so re-completing updates the same row.
ProjectData.pushSOP = function (projectId, sop, state) {
if (!projectId) return Promise.resolve(null);
enqueue({
return Promise.resolve(enqueue({
kind: 'sop', key: 'sop__' + projectId,
body: {
id: 'sop__' + projectId, project_id: projectId,
@@ -436,22 +661,21 @@
number: (sop && sop.project && sop.project.number) || '',
complete: true, created_by: currentUser(), data: { sop: sop, state: state }
}
});
return Promise.resolve(true);
}));
};
// Upsert a single Work Package. The local cache stays the source of truth for
// immediate rendering; the outbox guarantees the write reaches the server.
ProjectData.pushWP = function (p, projectId) {
if (!p || !p.id) return Promise.resolve(null);
enqueue({ kind: 'wp', key: p.id, body: pkgToServer(p, projectId) });
return Promise.resolve(true);
// D26: resolves false when the device could not store the change (it is still
// sent from memory, but it is lost if the page closes first).
return Promise.resolve(enqueue({ kind: 'wp', key: p.id, body: pkgToServer(p, projectId) }));
};
ProjectData.removeWP = function (id) {
if (!id) return Promise.resolve();
enqueue({ kind: 'wp-del', key: id });
return Promise.resolve(true);
return Promise.resolve(enqueue({ kind: 'wp-del', key: id }));
};
// Force a flush now and resolve when the queue drains (or a round-trip is done).

View File

@@ -24,11 +24,11 @@
The directory is one wide table, so the column exceptions live here: email is
the one cell long enough to stretch a row, and the two role dropdowns need
room for "Assistant Project Manager" without pushing Actions off screen. */
#users-table table td:nth-child(3){ max-width:230px; overflow:hidden; text-overflow:ellipsis; }
/* The email cell, by its class: CR-020's selection column moved it from third to
fourth on the managers' table, and a position-based rule would have followed
the wrong column. */
#users-table table td.ell{ max-width:230px; overflow:hidden; text-overflow:ellipsis; }
#users-banner:not(:empty), #scope-banner:not(:empty){ margin-bottom:var(--s3); }
/* The create form is a lot of fields; give the password one room to breathe and
let the project picker take a full row of its own. */
#nu-password{ flex:1 1 200px; }
#nu-projects{ margin-top:var(--s2); }
#nu-projects .pickrow{ padding:var(--s1) var(--s1); }
/* A manager with one project doesn't need a scrolling picker; a manager with
@@ -36,9 +36,48 @@
#nu-project-list{ max-height:200px; overflow:auto; border:1px solid var(--border); }
.whoami-chip{ font-size:12px; color:var(--muted); }
.whoami-chip strong{ color:var(--text); }
/* CR-020: row selection and the bulk bar. Tokens only (the token rule). */
#sel-banner:not(:empty), #bulk-banner:not(:empty), #csv-banner:not(:empty){ margin-bottom:var(--s3); }
#bulk-banner ul, #csv-banner ul{ margin:var(--s1) 0 0; padding-left:var(--s5); font-weight:400;
max-height:220px; overflow:auto; }
#csv-btn[hidden]{ display:none; }
table.grid th.selcell, table.grid td.selcell{ width:1%; padding:0 var(--s1); text-align:center; }
/* The label is the hit area: the 16px box alone is under the 24px floor. */
.selhit{ display:inline-flex; align-items:center; justify-content:center;
min-width:28px; min-height:28px; cursor:pointer; }
.selhit input{ width:16px; height:16px; margin:0; accent-color:var(--accent); cursor:pointer; }
.selhit input:focus-visible{ outline:2px solid var(--accent); outline-offset:2px; }
.selhit input:disabled{ cursor:default; }
/* Not --accent-soft: that is the admin pill's own fill (console.css, hover note). */
table.grid tbody tr.is-selected td{ background:var(--cds-layer-selected); }
table.grid tbody tr.is-selected td.selcell{ box-shadow:inset 3px 0 0 var(--accent); }
.bulkbar{ border:1px solid var(--accent); border-left:3px solid var(--accent);
background:var(--surface); padding:var(--s2) var(--s3); margin:0 0 var(--s3); }
.bulkbar[hidden]{ display:none; }
.bulkhead{ display:flex; align-items:center; justify-content:space-between; gap:var(--s2);
flex-wrap:wrap; margin-bottom:var(--s2); }
.bulkgroup{ display:flex; flex-wrap:wrap; align-items:center; gap:var(--s2);
padding:var(--s2) 0; border-top:1px solid var(--border); }
.bulkgroup > .bulklabel{ font-size:12px; font-weight:600; color:var(--muted); min-width:110px; }
.bulkgroup select{ height:var(--ctl); padding:0 var(--s1) 0 var(--s2); font:inherit; font-size:13px;
border:1px solid var(--border-strong); border-radius:0; background:var(--surface); color:var(--text);
max-width:100%; }
.bulkgroup select:focus-visible{ outline:2px solid var(--accent); outline-offset:-2px; }
/* The bulk delete dialog lists every affected username; a long list scrolls
inside the dialog instead of pushing its buttons off the screen. */
#wp-dlg-msg{ max-height:50vh; overflow:auto; }
@media (max-width:620px){
.bulkgroup > .bulklabel{ min-width:0; flex:1 1 100%; }
.bulkgroup select, .bulkgroup button{ flex:1 1 100%; }
}
@media (pointer:coarse){
.selhit{ min-width:44px; min-height:44px; }
.bulkbar button, .bulkgroup select{ min-height:44px; }
}
</style>
</head>
<body>
<body data-wp-no-sync-badge>
<!-- SHARED DARK APP BAR -->
<header class="wp-appbar">
@@ -66,15 +105,33 @@
<div class="sub" id="people-sub"></div>
<div class="toolbar">
<button onclick="loadUsers()">Refresh</button>
<input id="user-search" placeholder="Search name / username / email / job function…" oninput="renderUsers()">
<select id="user-filter" onchange="renderUsers()">
<input id="user-search" placeholder="Search name / username / email / job function…" oninput="filterChanged()"
aria-label="Search the directory">
<select id="user-filter" onchange="filterChanged()" aria-label="Show">
<option value="">Everyone</option>
<option value="active">Active only</option>
<option value="disabled">Disabled only</option>
<option value="mine">Accounts I manage</option>
</select>
<!-- CR-020 (T12.4): a list of usernames from a file becomes the selection.
Managers only; users.js shows it. -->
<button type="button" id="csv-btn" onclick="pickCsv()" hidden
title="A CSV with one username (or email) per line, first column. The action is chosen in the bulk bar.">Select from CSV…</button>
<input type="file" id="csv-file" accept=".csv,.txt,text/csv,text/plain" hidden>
</div>
<div id="users-banner"></div>
<div id="csv-banner"></div>
<!-- CR-020: bulk actions on the selected rows. Present only while at least one
row is selected (the hidden attribute also takes it out of the tab order). -->
<div id="bulk-bar" class="bulkbar" role="region" aria-label="Bulk actions on the selected users" hidden>
<div class="bulkhead">
<strong id="bulk-count">0 selected</strong>
<button type="button" onclick="clearSelection(true)">Clear selection</button>
</div>
<div id="bulk-actions"></div>
</div>
<div id="sel-banner"></div>
<div id="bulk-banner"></div>
<div id="users-table"><div class="note">Loading…</div></div>
</div>
@@ -83,12 +140,12 @@
<h2>Add a user</h2>
<div class="sub" id="create-sub"></div>
<div class="urow">
<input id="nu-username" placeholder="Username *" autocomplete="off">
<input id="nu-username" placeholder="Username *" autocomplete="off"
title="Must exactly match this person's Okta sign-in identity — that's how their first Okta sign-in finds this account instead of creating a second one.">
<input id="nu-fullname" placeholder="Full name" autocomplete="off">
<input id="nu-email" placeholder="Email" autocomplete="off">
<select id="nu-role" title="Permissions — what this account may do"></select>
<select id="nu-project-role" title="Job function on the project"></select>
<input id="nu-password" type="password" placeholder="Password (min 12)" autocomplete="new-password">
</div>
<div id="nu-projects">
<div class="note" id="nu-projects-label" style="margin-bottom:var(--s1)"></div>

View File

@@ -23,6 +23,10 @@
let _users = []; // the directory as the server scoped it
let _scope = null; // GET /api/auth/user-scope
let _meId = null;
// CR-020: the rows checked for a bulk action. Client-side UI state only - every
// bulk action is decided and audited by the server, row by row (T12.1).
let _selected = new Set();
let _shownSelectable = []; // ids the current filter shows AND this caller may select
// ── boot ──────────────────────────────────────────────────────────────────────
async function boot(){
@@ -40,6 +44,7 @@ async function boot(){
renderScope();
}
renderCreateForm();
renderBulkActions();
loadUsers();
}
@@ -90,11 +95,309 @@ async function loadUsers(){
}
banner('users-banner','', '');
_users = json;
// Fresh data: any earlier selection may name accounts that changed or are gone.
clearSelection(false);
renderUsers();
}
function manages(){ return !!(_scope && _scope.can_manage_users); }
// ── selection (CR-020, T12.2) ─────────────────────────────────────────────────
// A row is selectable when this caller may change the account. Your own row is
// not: every bulk action that could touch it (disable, demote, delete) is refused
// for your own account, so offering it would only produce a guaranteed failure.
function selectable(u){ return manages() && !!u.manageable && u.id !== _meId; }
// The search box and the filter both decide which rows are shown. Changing either
// clears the selection (decided 2026-10-06), so no row hidden by the filter can
// stay selected and be acted on without being seen.
function filterChanged(){
const had = _selected.size;
clearSelection(false);
renderUsers();
banner('sel-banner', '', had ? 'Selection cleared: the filter changed. Select the rows again.' : '');
}
function clearSelection(announce){
const had = _selected.size;
_selected = new Set();
updateSelectionUI();
banner('sel-banner', '', (announce && had) ? 'Selection cleared.' : '');
}
function setRowSelected(id, on){
if(on) _selected.add(id); else _selected.delete(id);
}
// Select-all acts on the rows the filter shows, never on the whole directory.
function toggleSelectAll(on){
_shownSelectable.forEach(id => setRowSelected(id, on));
banner('sel-banner', '', '');
updateSelectionUI();
}
// Reflect _selected into the page without re-rendering the table, so keyboard
// focus stays on the checkbox that was just used.
function updateSelectionUI(){
const wrap = document.getElementById('users-table');
if(wrap){
wrap.querySelectorAll('input.selbox').forEach(cb => {
const on = _selected.has(cb.dataset.id);
cb.checked = on;
const tr = cb.closest('tr');
if(tr) tr.classList.toggle('is-selected', on);
});
const all = document.getElementById('sel-all');
if(all){
const n = _shownSelectable.filter(id => _selected.has(id)).length;
all.checked = n > 0 && n === _shownSelectable.length;
all.indeterminate = n > 0 && n < _shownSelectable.length;
all.disabled = !_shownSelectable.length;
}
}
const bar = document.getElementById('bulk-bar');
if(bar){
const n = _selected.size;
bar.hidden = n === 0;
const c = document.getElementById('bulk-count');
if(c) c.textContent = n + ' selected';
}
}
// One listener for every checkbox in the table (event delegation): no ids are
// bound into inline handlers, so there is nothing to escape.
document.addEventListener('change', e => {
const t = e.target;
if(!(t instanceof HTMLInputElement)) return;
if(t.id === 'sel-all'){ toggleSelectAll(t.checked); return; }
if(t.classList.contains('selbox')){
setRowSelected(t.dataset.id, t.checked);
banner('sel-banner', '', '');
updateSelectionUI();
}
});
// ── bulk actions (CR-020, T12.3) ──────────────────────────────────────────────
// The toolbar offers only what this caller may do: the roles they may grant, the
// projects they administer, the per-project roles they may hand out. The server
// re-checks every row anyway (T12.1); this is so nobody is offered a choice that
// can only fail.
function renderBulkActions(){
const box = document.getElementById('bulk-actions');
const csvBtn = document.getElementById('csv-btn');
if(csvBtn) csvBtn.hidden = !manages();
if(!box || !manages()) return;
const grantable = PERM_ROLES.filter(r => (_scope.grantable_roles || []).indexOf(r) >= 0);
const projects = (_scope.managed_projects || []).slice()
.sort((a,b) => (a.archived?1:0) - (b.archived?1:0));
const projRoles = PROJECT_SCOPED_ROLES.filter(r => (_scope.grantable_project_roles || []).indexOf(r) >= 0);
const group = (label, inner) => '<div class="bulkgroup" role="group" aria-label="'+uesc(label)+'">'+
'<span class="bulklabel">'+uesc(label)+'</span>'+inner+'</div>';
box.innerHTML =
group('Permissions',
'<select id="bulk-role" aria-label="New permissions role">'+
grantable.map(r => '<option value="'+r+'"'+(r==='project_user'?' selected':'')+'>'+uesc(PERM_LABELS[r])+'</option>').join('')+
'</select>'+
'<button type="button" onclick="bulkRole()">Set permissions</button>') +
group('Sign-in',
'<button type="button" onclick="bulkActive(true)">Enable</button>'+
'<button type="button" onclick="bulkActive(false)">Disable</button>') +
(projects.length ? group('Project access',
'<select id="bulk-project" aria-label="Project">'+
projects.map(p => '<option value="'+uesc(p.id)+'">'+uesc((p.name||'(unnamed)')+(p.number?' '+p.number:'')+
(p.archived?' (archived)':''))+'</option>').join('')+
'</select>'+
'<select id="bulk-project-role" aria-label="Role on that project, for Add">'+
'<option value="">Role: same as account</option>'+
projRoles.map(r => '<option value="'+r+'">Role: '+uesc(PERM_LABELS[r])+' here</option>').join('')+
'</select>'+
'<button type="button" onclick="bulkProject(\'add\')">Add to project</button>'+
'<button type="button" onclick="bulkProject(\'remove\')">Remove from project</button>') : '') +
group('Delete',
'<button type="button" class="danger" onclick="bulkDelete()">Delete selected…</button>');
}
function selectedIds(){ return _users.filter(u => _selected.has(u.id)).map(u => u.id); }
function people(n){ return n + ' user' + (n === 1 ? '' : 's'); }
function selVal(id){ return (document.getElementById(id) || {}).value || ''; }
function selText(id){
const s = document.getElementById(id);
return (s && s.selectedIndex >= 0) ? s.options[s.selectedIndex].text : '';
}
// One path for every bulk action: confirm through the dialog kit with the exact
// count, send, report row by row, reload. A reload clears the selection, which is
// right: the rows may have changed underneath it.
async function runBulk(path, body, ask){
const ids = selectedIds();
if(!ids.length) return;
if(!(await wpConfirmDialog({title: ask.title, okLabel: ask.ok, message: ask.message(ids.length)}))) return;
return sendBulk(path, body, ask.title, ids);
}
async function sendBulk(path, body, title, ids){
bannerHtml('bulk-banner', '', uesc(title)+': working on '+uesc(people(ids.length))+'…');
const { status, json } = await api('POST', path, Object.assign({ user_ids: ids }, body));
if(status !== 200 || !json || !Array.isArray(json.results)){
bannerHtml('bulk-banner', 'bad', '✕ '+uesc(apiError(status, json, title+' failed'))+' Nothing was changed.');
return;
}
showBulkResult(json, title);
loadUsers();
}
// T12.5: delete is permanent (a hard delete, as for one account) and one bad
// multi-select now removes many, so it asks more than the other actions do:
// every affected username is listed, and nothing is sent until the word DELETE
// is typed, whatever the count (confirmed 2026-10-06). Your own account cannot
// be selected; if it ever reached the request, the server refuses that row and
// the report names it.
async function bulkDelete(){
const chosen = _users.filter(u => _selected.has(u.id));
if(!chosen.length) return;
const n = chosen.length;
const typed = await wpPromptDialog({
title: 'Delete '+people(n),
message: 'Delete '+(n === 1 ? 'this account' : 'these '+n+' accounts')+'? Each one, and every project '+
'assignment it has, is removed. This cannot be undone. Disable them instead if you only want to '+
'block sign-in.\n\n'+chosen.map(u => '• '+u.username+(u.full_name ? ' ('+u.full_name+')' : '')).join('\n'),
label: 'Type DELETE to confirm',
value: '',
okLabel: 'Delete '+people(n),
validate: v => v === 'DELETE' ? '' : 'Type DELETE, in capital letters, to confirm.',
});
if(typed !== 'DELETE') return;
return sendBulk('/api/auth/bulk-users/delete', {}, 'Delete accounts', chosen.map(u => u.id));
}
// Every row is accounted for: changed, already so, or failed with the server's
// reason. A batch that partly failed never reads as a success (CR-020).
function showBulkResult(json, title){
const failed = json.results.filter(r => r.status === 'failed');
const parts = [json.ok+' changed'];
if(json.unchanged) parts.push(json.unchanged+' already set');
if(failed.length) parts.push(failed.length+' failed');
const kind = !failed.length ? 'ok' : (json.ok + json.unchanged ? 'warn' : 'bad');
const lead = (failed.length ? (kind === 'bad' ? '✕ ' : '⚠ ') : '✓ ')+uesc(title)+': '+parts.join(', ')+'.';
const list = failed.length
? '<ul>'+failed.map(r => '<li><strong>'+uesc(r.username || r.user_id)+'</strong>: '+uesc(r.reason)+'</li>').join('')+'</ul>'
: '';
bannerHtml('bulk-banner', kind, lead + list);
}
function bannerHtml(id, kind, html){
const el = document.getElementById(id);
if(!el) return;
el.className = 'banner' + (kind ? ' '+kind : '');
el.innerHTML = html;
}
function bulkRole(){
const role = selVal('bulk-role');
if(!role) return;
return runBulk('/api/auth/bulk-users/role', { role }, {
title: 'Set permissions', ok: 'Change permissions',
message: n => 'Set permissions to '+(PERM_LABELS[role] || role)+' for '+people(n)+'?\n\n'+
'Each account is checked on its own. Any that cannot be changed are listed afterwards.'});
}
function bulkActive(on){
return runBulk('/api/auth/bulk-users/active', { is_active: !!on }, {
title: on ? 'Enable accounts' : 'Disable accounts', ok: on ? 'Enable' : 'Disable',
message: n => (on ? 'Enable sign-in for ' : 'Disable sign-in for ')+people(n)+'?'+
(on ? '' : '\n\nA disabled account cannot sign in. Nothing else about it changes.')});
}
function bulkProject(op){
const pid = selVal('bulk-project');
if(!pid) return;
const role = op === 'add' ? selVal('bulk-project-role') : '';
const pname = selText('bulk-project');
return runBulk('/api/auth/bulk-users/projects', { project_id: pid, op, role }, {
title: op === 'add' ? 'Add to project' : 'Remove from project',
ok: op === 'add' ? 'Add' : 'Remove',
message: n => op === 'add'
? 'Add '+people(n)+' to '+pname+' with '+(role ? PERM_LABELS[role]+' on that project' : 'their account role')+'?\n\n'+
'Their other projects, and their roles there, stay as they are.'
: 'Remove '+people(n)+' from '+pname+'?\n\nTheir other projects stay as they are.'});
}
// ── CSV upload (CR-020, T12.4) ────────────────────────────────────────────────
// The file holds usernames only (decided 2026-10-06). The server reads it and
// answers line by line; the accepted accounts become the ordinary selection, so
// the action, its confirmation and its row-by-row report are the same ones the
// checkboxes use. A CSV cannot reach an account a checkbox could not: the bulk
// route re-checks every row.
const CSV_MAX_BYTES = 1024 * 1024;
// Blob.text() where the browser has it, FileReader where it does not (older
// tablet browsers).
function readFileText(file){
if(typeof file.text === 'function') return file.text();
return new Promise((resolve, reject) => {
const r = new FileReader();
r.onload = () => resolve(String(r.result || ''));
r.onerror = () => reject(r.error);
r.readAsText(file);
});
}
function pickCsv(){
const f = document.getElementById('csv-file');
if(f){ f.value = ''; f.click(); }
}
document.addEventListener('change', e => {
if(e.target && e.target.id === 'csv-file' && e.target.files && e.target.files[0]) loadCsv(e.target.files[0]);
});
async function loadCsv(file){
if(file.size > CSV_MAX_BYTES){
bannerHtml('csv-banner', 'bad', '✕ '+uesc(file.name)+' is larger than 1 MB. Split it and load the parts one at a time.');
return;
}
let text = '';
try { text = await readFileText(file); }
catch(_){ bannerHtml('csv-banner', 'bad', '✕ Could not read '+uesc(file.name)+'.'); return; }
bannerHtml('csv-banner', '', 'Reading '+uesc(file.name)+'…');
const { status, json } = await api('POST', '/api/auth/bulk-users/resolve', { text });
if(status !== 200 || !json || !Array.isArray(json.rows)){
bannerHtml('csv-banner', 'bad', '✕ '+uesc(apiError(status, json, 'Could not read the list')));
return;
}
// Show everyone, so every accepted account is a visible, checked row: a
// selection must never include a row the filter hides.
const s = document.getElementById('user-search'), f = document.getElementById('user-filter');
if(s) s.value = '';
if(f) f.value = '';
await loadUsers();
const want = new Set(json.user_ids || []);
_shownSelectable.forEach(id => { if(want.has(id)) _selected.add(id); });
updateSelectionUI();
const missed = [...want].filter(id => !_selected.has(id)).length;
const rejected = json.rows.filter(r => r.status !== 'ok');
const lead = (rejected.length || missed ? '⚠ ' : '✓ ')+uesc(file.name)+': '+json.read+' line'+(json.read===1?'':'s')+' read, '+
_selected.size+' selected'+(rejected.length ? ', '+rejected.length+' rejected' : '')+'.'+
(missed ? ' '+missed+' accepted account'+(missed===1?' is':'s are')+' no longer in the directory; reload and try again.' : '')+
(_selected.size ? ' Pick an action in the bulk bar to apply it to the selected accounts.' : '');
const list = rejected.length
? '<ul>'+rejected.map(r => '<li>Line '+r.line+' ('+uesc(r.text)+'): '+uesc(r.reason)+'</li>').join('')+'</ul>'
: '';
bannerHtml('csv-banner', (rejected.length || missed) ? 'warn' : 'ok', lead + list);
}
function selCell(u){
if(!selectable(u)){
const why = u.id === _meId ? 'Your own account: change it one setting at a time'
: (u.manage_blocked_reason || 'You cannot change this account');
return '<td class="selcell"><span class="selhit" title="'+uesc(why)+'">'+
'<input type="checkbox" disabled aria-label="'+uesc('Cannot select '+u.username+': '+why)+'"></span></td>';
}
return '<td class="selcell"><label class="selhit">'+
'<input type="checkbox" class="selbox" data-id="'+uesc(u.id)+'"'+(_selected.has(u.id)?' checked':'')+
' aria-label="'+uesc('Select '+u.username)+'"></label></td>';
}
function renderUsers(){
const wrap = document.getElementById('users-table');
const q = ((document.getElementById('user-search')||{}).value||'').trim().toLowerCase();
@@ -116,7 +419,8 @@ function renderUsers(){
(u.project_role||'')+' '+roleLabel(u.role)).toLowerCase().indexOf(q) >= 0;
});
const count = '<div class="note">'+list.length+' of '+total+' '+(total===1?'person':'people')+'</div>';
if(!list.length){ wrap.innerHTML = count+'<div class="note">Nothing matches.</div>'; return; }
_shownSelectable = list.filter(selectable).map(u => u.id);
if(!list.length){ wrap.innerHTML = count+'<div class="note">Nothing matches.</div>'; updateSelectionUI(); return; }
const head = manages()
? ['Username','Name','Email',
@@ -130,9 +434,16 @@ function renderUsers(){
'Status'];
const ths = head.map(h => Array.isArray(h)
? '<th title="'+uesc(h[1])+'">'+uesc(h[0])+'</th>' : '<th>'+uesc(h)+'</th>').join('');
// CR-020: a selection column for anyone who manages accounts. Select-all names
// how many rows it covers, because it covers only what the filter shows.
const selTh = manages()
? '<th class="selcell"><label class="selhit"><input type="checkbox" id="sel-all" aria-label="'+
uesc('Select all '+_shownSelectable.length+' shown that you can change')+'"></label></th>'
: '';
const rows = list.map(manages() ? managerRow : readonlyRow).join('');
wrap.innerHTML = count+'<div class="tscroll"><table class="grid"><thead><tr>'+ths+
wrap.innerHTML = count+'<div class="tscroll"><table class="grid"><thead><tr>'+selTh+ths+
'</tr></thead><tbody>'+rows+'</tbody></table></div>'+legend();
updateSelectionUI();
}
function legend(){
@@ -183,14 +494,13 @@ function managerRow(u){
: projRoleReadonly(u, can, why);
const actions = [];
if(can && !me) actions.push('<button class="mini" onclick="resetPw(\''+uid+'\',\''+uname+'\')">Reset password</button>');
if(can && !me) actions.push('<button class="mini" onclick="toggleActive(\''+uid+'\','+(!u.is_active)+')">'+
(u.is_active?'Disable':'Enable')+'</button>');
if(can && !me) actions.push('<button class="mini danger" onclick="deleteUser(\''+uid+'\',\''+uname+'\')">Delete</button>');
if(me) actions.push('<button class="mini" disabled title="Use the Password link in the top bar to change your own">—</button>');
if(!can && !me) actions.push('<span class="note" style="margin:0" title="'+uesc(why)+'">read-only</span>');
return '<tr'+(can||me ? '' : ' class="is-locked"')+'>'+
selCell(u)+
'<td><strong>'+uesc(u.username)+'</strong>'+(me?'<span class="me-tag">you</span>':'')+'</td>'+
'<td>'+uesc(u.full_name||'')+'</td>'+
// The address is truncated with the full value on the title: a long one used to
@@ -254,19 +564,6 @@ function projAccessCell(u){
// ── row actions ───────────────────────────────────────────────────────────────
// Each one reloads on failure so a control can never sit there showing a value the
// server refused.
async function resetPw(id, username){
// The min-12 rule was stated in the prompt label and enforced only by the
// server round-trip; the kit's validate() answers AT the input instead.
const pw = await wpPromptDialog({title:'Reset password',
message:'Set a new password for "'+username+'". Their existing sessions are signed out.',
label:'New password (min 12 characters)',
validate:v => (v && v.length >= 12) ? '' : 'At least 12 characters.'});
if(pw === null) return;
const { status, json } = await api('POST','/api/auth/users/'+id+'/password',{new_password:pw});
if(status === 200) toast('Password reset for '+username+'. Their existing sessions are signed out.');
else wpAlertDialog({title:'Reset failed', message:'Could not reset the password: '+apiError(status, json)});
}
async function toggleActive(id, makeActive){
const { status, json } = await api('POST','/api/auth/users/'+id+'/active',{is_active:makeActive});
if(status === 200) loadUsers();
@@ -344,25 +641,27 @@ function renderCreateForm(){
async function createUser(){
const msg = document.getElementById('users-create-msg');
const val = id => (document.getElementById(id)||{}).value || '';
// The username entered here MUST match what Okta's identity claim will send for
// this person exactly — this creates the account ahead of their first sign-in,
// and that's how a later Okta sign-in finds this row instead of provisioning a
// second one. See create_user()'s docstring in server/app.py.
const username = val('nu-username').trim();
const password = val('nu-password');
const project_ids = [...document.querySelectorAll('#nu-project-list input[type=checkbox]:checked')]
.map(c => c.value);
const say = (color, text) => { msg.style.color = color; msg.textContent = text; };
if(!username){ say('var(--red)','Username is required.'); return; }
if(password.length < 12){ say('var(--red)','Password must be at least 12 characters.'); return; }
if(_scope.scope !== 'all' && !project_ids.length){
say('var(--red)','Pick at least one project — you administer users per project.'); return;
}
say('var(--muted)','Creating…');
const { status, json } = await api('POST','/api/auth/users',{
username, password, project_ids,
username, project_ids,
full_name: val('nu-fullname').trim(), email: val('nu-email').trim(),
role: val('nu-role'), project_role: val('nu-project-role'),
});
if(status === 200){
say('var(--green)','✓ Created '+username+'.');
['nu-username','nu-fullname','nu-email','nu-password'].forEach(id => document.getElementById(id).value = '');
['nu-username','nu-fullname','nu-email'].forEach(id => document.getElementById(id).value = '');
loadUsers();
} else {
say('var(--red)','✕ '+apiError(status, json, 'Could not create the account'));

View File

@@ -2207,20 +2207,18 @@ function loadStepComments(){
}
}
// ── USAGE ANALYTICS ─────────────────────────────────────────────────────────
// Lightweight usage analytics stored in localStorage so the tool owner can review
// engagement over time. No field VALUES are stored (field-edit events record only
// the field id), keeping captured data non-sensitive.
// D5 / T7.10: the analytics implementation lives in wp-usage.js and the report
// on the admin console. The wizard's own copy of showAnalytics() never had a
// caller here - the button lived on the creator - and once B7 dissolved the
// frame the duplicate sat in the same document as five colliding globals.
// This page only records; dwell tracking keeps its page-local state below.
// ── USAGE ANALYTICS (retired, T11.6) ────────────────────────────────────────
// This used to write to wp-usage.js's per-browser localStorage log (D5/T7.10),
// read back by the admin console's old "Usage logs" panel. CR-019 replaced
// both with real, server-side, per-user activity (UsageEvent + the Activity &
// usage card) - see decisions-2026-09-17.md for why this per-browser data was
// never a source the new report could adopt. track() is now a no-op; kept
// (rather than deleting its handful of call sites, including the dwell-timer
// plumbing below) so this stays a one-line change instead of touching every
// caller for the same outcome.
let _stepEnter = Date.now();
function track(event, detail){
WPUsage.track(WPUsage.KEYS.wizard, event, detail);
}
function track(event, detail){ /* retired, T11.6 — see comment above */ }
function trackStepDwell(){
const ms = Date.now() - _stepEnter;
if(ms > 400 && ms < 1000*60*60) track('step_dwell', {step: currentStep, ms});

View File

@@ -11,7 +11,6 @@
<!-- Addressable state (S3). Parses before the app scripts, which read the URL
during their own boot. -->
<script src="wp-url.js"></script>
<script src="wp-usage.js"></script>
<script src="wp-list-import.js"></script>
<!-- Autosave, unsaved-work guard, draft recovery (S2). -->
<script src="wp-autosave.js"></script>

View File

@@ -3993,11 +3993,17 @@ function openSopModal(){
document.getElementById('sop-modal').classList.add('open'); track('view_sop');
}
function closeSopModal(){ document.getElementById('sop-modal').classList.remove('open'); }
// D5 / T7.10: the analytics implementation lives in wp-usage.js - ONE copy for
// the whole suite - and its report lives on the admin console, where an
// operator-facing readout belongs. This page only records. Same key, same
// event shape: everything recorded before the move is still readable after it.
function track(event,detail){ if(devMode) return; WPUsage.track(WPUsage.KEYS.creator, event, detail); }
// CR-019 / T11.6 (2026-09-23): this used to write to wp-usage.js's per-browser
// localStorage log (D5/T7.10). Retired along with the admin console's old
// "Usage logs" panel, its only reader - real, server-side, per-user activity
// now exists (UsageEvent, the Activity & usage card, T11.1-T11.5) and this
// data was never reliably tied to a real identity anyway, so it was not a
// source the new report could adopt (decisions-2026-09-17.md). track() stays
// as a no-op rather than deleting its ~35 call sites throughout this file:
// removing every call individually is a much larger, riskier diff for the
// same outcome, and a call site here still documents the moment worth
// recording if usage analytics are ever rebuilt server-side.
function track(event,detail){ /* retired, T11.6 — see comment above */ }
// ── COMMENTS ─────────────────────────────────────────────────────────────────
const COMMENTS_KEY='wp_iwp_comments_v1';

View File

@@ -11,7 +11,6 @@
<!-- Addressable state (S3). Parses before the app scripts, which read the URL
during their own boot. -->
<script src="wp-url.js"></script>
<script src="wp-usage.js"></script>
<!-- Autosave, unsaved-work guard, draft recovery (S2). -->
<script src="wp-autosave.js"></script>
<!-- Which sections this project uses (CR-006). The same file the SOP wizard

View File

@@ -220,7 +220,8 @@
.then(function (res) {
if (!res.ok) { msg((res.j && res.j.detail) || ('Could not save (HTTP ' + res.status + ').'), false); return; }
if (res.j && res.j.user) window.WP_USER = res.j.user;
try { localStorage.setItem('wp_auth_cache', JSON.stringify({ user: window.WP_USER, at: Date.now() })); } catch (e) {}
// D27: refresh the cached user, but not the end of the session.
try { if (window.wpCacheAuth) window.wpCacheAuth(window.WP_USER); } catch (e) {}
msg('Saved. Reloading so every date on the page agrees…', true);
// Dates are formatted at render time all over the app; a reload is the
// honest way to apply the change everywhere at once.

View File

@@ -105,6 +105,18 @@
say(bits.join(''), problem);
}
// A 500 answers plain text ("Internal Server Error"), and r.json() on that
// throws - which used to land in catch() and read as "could not reach the
// server" while the server was answering fine (found 2026-08-23, the
// production locations import). Read text, parse if it parses, keep status.
function readJson(r) {
return r.text().then(function (t) {
var j = null;
try { j = t ? JSON.parse(t) : null; } catch (e) { /* not JSON: a proxy or 500 page */ }
return { ok: r.ok, status: r.status, body: j };
});
}
function importText(dryRun) {
var text = (el(p + '-paste') || {}).value || '';
if (!text.trim()) { say('Paste some rows or choose a CSV file first.', true); return; }
@@ -114,7 +126,7 @@
method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
body: JSON.stringify({ text: text, dry_run: !!dryRun }),
})
.then(function (r) { return r.json().then(function (j) { return { ok: r.ok, status: r.status, body: j }; }); })
.then(readJson)
.then(function (res) {
if (!res.ok) {
say('⚠ Import refused — ' + esc((res.body && res.body.detail) || ('HTTP ' + res.status)), true);
@@ -142,7 +154,7 @@
method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
body: JSON.stringify(read.payload),
})
.then(function (r) { return r.json().then(function (j) { return { ok: r.ok, status: r.status, body: j }; }); })
.then(readJson)
.then(function (res) {
if (!res.ok) {
setAddError((res.body && res.body.detail) || ('Could not add it (HTTP ' + res.status + ')'));
@@ -161,7 +173,7 @@
method: 'PATCH', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
body: JSON.stringify(patchBody),
})
.then(function (r) { return r.json().then(function (j) { return { ok: r.ok, status: r.status, body: j }; }); })
.then(readJson)
.then(function (res) {
if (!res.ok) {
say('⚠ ' + esc((res.body && res.body.detail) || ('HTTP ' + res.status)), true);

View File

@@ -53,7 +53,6 @@
{ section: 'Account' },
{ action: 'wpPreferences', icon: '◷', label: 'Language & time',
sub: 'Dates, numbers and time zone' },
{ action: 'wpChangePassword', icon: '⚿', label: 'Password', sub: 'Change your password' },
];
function esc(v) {

View File

@@ -1,58 +0,0 @@
/* Usage analytics core — the ONE implementation (D5 / T7.10).
This existed three times: the creator's copy, the wizard's copy (which had no
caller — the button lived on the creator), and the admin console's own reader.
Once the creator stopped being an iframe (B7/T7.1) the first two sat in one
document as five colliding globals; an unreferenced duplicate is exactly what
produced D5. One core now; the pages keep only a thin track() wrapper because
page state (the creator's dev-mode pause) belongs to the page.
The storage KEYS are unchanged on purpose: everything recorded before this
file existed is still readable through it. No field VALUES are ever stored —
a field-edit event records the field id, nothing else.
Classic script, no modules: exposes window.WPUsage. */
'use strict';
(function () {
var SESSION = 's_' + Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
function load(key) {
try { return JSON.parse(localStorage.getItem(key)) || { events: [] }; }
catch (e) { return { events: [] }; }
}
function save(key, data) {
try { localStorage.setItem(key, JSON.stringify(data)); }
catch (e) { /* storage unavailable — degrade silently */ }
}
function track(key, event, detail) {
try {
var d = load(key);
d.events.push({ ts: new Date().toISOString(), session: SESSION, event: event, detail: detail || null });
if (d.events.length > 5000) d.events = d.events.slice(-5000);
save(key, d);
} catch (e) { /* never let telemetry break the tool it watches */ }
}
function download(key, prefix) {
var blob = new Blob([JSON.stringify(load(key), null, 2)], { type: 'application/json' });
var a = document.createElement('a');
a.href = URL.createObjectURL(blob);
a.download = (prefix || 'wp-usage') + '-' + new Date().toISOString().slice(0, 10) + '.json';
document.body.appendChild(a);
a.click();
a.remove();
setTimeout(function () { URL.revokeObjectURL(a.href); }, 1000);
}
window.WPUsage = {
load: load,
save: save,
track: track,
download: download,
// The pre-D5 keys, verbatim — continuity of the recorded data is a done-when.
KEYS: { creator: 'wp_iwp_analytics_v1', wizard: 'wp_suite_analytics_v1' },
};
})();

View File

@@ -12,14 +12,101 @@ DATABASE_URL=postgresql+psycopg://wpsuite:CHANGE_ME@localhost:5432/wpsuite
# CORS_ORIGINS=http://localhost:5500
# ── Authentication ────────────────────────────────────────────────────────────
# Secret used to sign session cookies (JWTs). REQUIRED in production: if unset,
# the API falls back to a random per-process key, so logins reset on every
# restart and break across multiple gunicorn workers. Generate a strong one:
# There is no local password (D15/D16) — Okta OIDC is the only way in. Sign-in
# still ends the same way it always did: a signed JWT in an HttpOnly session
# cookie, which is what the four vars right below this line are for. The five
# OKTA_* vars after that are what makes the actual sign-in possible; without
# them the API starts (this is not a hard failure like AUTH_SECRET_KEY), but
# describe()'s startup log line says so and nobody can sign in.
# Secret used to sign session cookies (JWTs), AFTER Okta has confirmed who
# someone is — this app still decides roles/authorization locally, unchanged
# by Okta (see server/okta_auth.py). REQUIRED in production: if unset, the API
# falls back to a random per-process key, so logins reset on every restart and
# break across multiple gunicorn workers. Generate a strong one:
# python -c "import secrets; print(secrets.token_urlsafe(48))"
AUTH_SECRET_KEY=CHANGE_ME_run_the_command_above
# How long a login lasts before re-authentication (hours). Default 12.
# AUTH_SESSION_HOURS=12
# How long a login lasts before re-authentication (hours). Default 8 (D25).
# AUTH_SESSION_HOURS=8
# ── Okta OIDC (required — this is the only sign-in path) ───────────────────────
# The Okta *authorization server* issuer, e.g. https://yourorg.okta.com/oauth2/default
# or a custom authorization server URL. The API discovers the authorize/token/
# jwks endpoints from <OKTA_ISSUER>/.well-known/openid-configuration — nothing
# else about Okta's endpoints is hand-entered.
OKTA_ISSUER=https://your-org.okta.com/oauth2/default
# Client ID and secret from the Okta app integration (Sign-in method: OIDC -
# Authorization Code, Application type: Web Application). The secret is exactly
# that — treat it like AUTH_SECRET_KEY, never commit it.
OKTA_CLIENT_ID=CHANGE_ME
OKTA_CLIENT_SECRET=CHANGE_ME
# Must exactly match a "Sign-in redirect URI" registered on the Okta app
# integration, scheme and path included, e.g.:
# https://wp-suite.company.local/api/auth/okta/callback
OKTA_REDIRECT_URI=CHANGE_ME
# Which ID token claim carries this person's directory identity, matched
# against the local users.username column (server/app.py's okta_callback()).
# preferred_username is Okta's usual default for an AD-imported user; override
# it if your security team's Okta configuration uses a different claim (upn,
# a custom claim, …) — no code change needed, just this value.
# OKTA_IDENTITY_CLAIM=preferred_username
# ── Okta deprovisioning sync (D18, wave 13) ────────────────────────────────────
# A scheduled job asks Okta who is still active and disables local accounts
# Okta no longer shows as active. It only ever DISABLES. It never re-enables.
# If Okta cannot be reached or answers with anything unexpected, the job changes
# NOTHING that cycle and logs the failure.
#
# A read-only Okta API token, created by the person who administers the Okta
# tenant (Security > API > Tokens). This is NOT the OIDC client secret above.
# It is a different credential with a different scope. Treat it like
# AUTH_SECRET_KEY: never commit it, never log it. Leave it unset and the sync
# stays off (the startup log says so).
# OKTA_API_TOKEN=CHANGE_ME
#
# Second way to sign in to the Management API (D23): an Okta "API Services" app that
# uses client authentication private_key_jwt. Set these two INSTEAD of OKTA_API_TOKEN.
# If OKTA_API_TOKEN is also set, the token is used.
# OKTA_SYNC_CLIENT_ID the client ID of that app (starts with 0oa)
# OKTA_SYNC_PRIVATE_KEY its PRIVATE key as a JWK, as JSON or as base64 of that JSON.
# In Portainer use base64: it has no quote marks to be mangled.
# The Okta app needs the scope okta.users.read granted (Okta API Scopes tab), an admin
# role such as Read-only Administrator assigned to it. If the app has "Require Demonstrating
# Proof of Possession (DPoP)" switched on, the sync detects that and uses DPoP by itself. The key is a secret: never commit it or paste it
# into chat or a ticket.
# OKTA_SYNC_DPOP: auto (default), on, or off. auto asks for a plain Bearer token first, and
# uses DPoP only if Okta answers invalid_dpop_proof. Set "on" to always use DPoP.
# Set "off" to never use it. You normally set nothing.
# OKTA_SYNC_DPOP=auto
# OKTA_SYNC_CLIENT_ID=0oaXXXXXXXXXXXXXXXXX
# OKTA_SYNC_PRIVATE_KEY=
# The Okta org URL that serves the Management API, e.g. https://yourorg.okta.com
# Optional. If unset, it is the scheme and host of OKTA_ISSUER. Must be https.
# OKTA_ORG_URL=https://your-org.okta.com
#
# Which Okta PROFILE attribute holds the value that matches users.username.
# Optional. By default it follows OKTA_IDENTITY_CLAIM: preferred_username reads
# profile.login, email reads profile.email, any other claim name reads the
# profile attribute of the same name. Set this only if your tenant builds the
# claim from a different attribute.
# OKTA_SYNC_PROFILE_ATTRIBUTE=login
#
# How often the sync runs, in seconds. Default 900 (15 minutes), proposed and not
# confirmed with IT. A value under 300 is raised to 300. Every api worker checks
# once a minute and one of them wins each cycle, so raising the worker count does
# not raise the call rate to Okta.
# OKTA_SYNC_INTERVAL_SECONDS=900
#
# Dry run (D22). Set to true for the first deploy. The sync then does everything
# except the change: it logs who it WOULD disable and writes nothing, and it writes
# no audit rows. Read the result with: docker compose logs api | grep "Okta sync"
# Remove it (or set it to false) to go live. Off by default.
# OKTA_SYNC_DRY_RUN=true
# ── Email notifications (optional) ─────────────────────────────────────────────
# WP-assignment emails are OFF by default and are turned on from the Admin

View File

@@ -14,12 +14,12 @@ browser → NGINX ──serves──> static site (index.html, …)
| Method | Path | Purpose |
|--------|------|---------|
| GET | `/api/health` | liveness check (unauthenticated) |
| POST | `/api/auth/login` | sign in (`{username, password}`) — sets the session cookie |
| GET | `/api/auth/okta/login` | redirects the browser to Okta's authorize endpoint (`?next=` optional) |
| GET | `/api/auth/okta/callback` | Okta redirects back here with the auth code; signs the person in |
| POST | `/api/auth/logout` | clear the session cookie |
| GET | `/api/auth/me` | the logged-in user |
| POST | `/api/auth/password` | change your own password |
| GET | `/api/auth/users` | list accounts (**admin**) |
| POST | `/api/auth/users` | create an account (**admin**) |
| POST | `/api/auth/users` | pre-create an account by username (**admin**) |
| DELETE | `/api/auth/users/{id}` | delete an account (**admin**) |
| POST | `/api/sops` | create/update a SOP (upsert by `id`) |
| GET | `/api/sops` | list SOP summaries |
@@ -40,50 +40,81 @@ fields (name, number, status, …) are promoted to columns for listing/filtering
---
## Login portal (user accounts)
## Sign-in (Okta)
The suite is gated by a username/password login. Sign-in issues a signed JWT
that rides in an **HttpOnly, SameSite=Lax** cookie (`wp_session`); the cookie is
marked **Secure** automatically whenever the request arrives over HTTPS (via
NGINX's `X-Forwarded-Proto`). There is no server-side session store — each
request is validated by checking the cookie's signature and expiry.
There is no local password anywhere in this app (D15/D16) — Okta OIDC is the
only way in. `login.html` is a single "Sign in with Okta" button; the actual
exchange is `server/okta_auth.py` (the Okta client config) and the two routes
in `server/app.py`: `okta_login()` sends the browser to Okta's authorize
endpoint, `okta_callback()` exchanges the code, matches the ID token's identity
claim against `users.username`, and signs the person in.
Sign-in still ends the same way it always did: a signed JWT in an **HttpOnly,
SameSite=Lax** cookie (`wp_session`), marked **Secure** automatically whenever
the request arrives over HTTPS (via NGINX's `X-Forwarded-Proto`). There is no
server-side session store — each request is validated by checking the cookie's
signature and expiry. Okta only confirms *who* someone is; this app still
decides *what* they may do — roles, project membership, everything below stays
local and unchanged by Okta.
**The real security boundary is the API:** every `/api/` data route is refused
with `401` unless a valid session cookie is present (see `auth_gate` in
`app.py`). The static pages additionally include `auth-guard.js`, which redirects
to `login.html` when there's no session — that's for UX, not protection.
Passwords are stored only as **bcrypt** hashes (`server/auth.py`). Roles are
`admin` (may manage users) and `user`.
**Access gating is Okta's job, not this app's.** Only accounts assigned to the
app integration in Okta can complete the sign-in flow at all, so there is no
required-group or claim check layered on top here. Once Okta lets someone
through, this app decides their role — see below.
### Set the signing secret
Roles are `admin`, `project_super_user`, `project_admin`, `project_user`
(`html/users.js`, enforced server-side).
Add `AUTH_SECRET_KEY` to `.env` (see `.env.example`). **Required in production** —
without it the API uses a random per-process key, so logins reset on restart.
### Set the signing secret and the Okta app integration
Add `AUTH_SECRET_KEY` and the five `OKTA_*` variables to `.env` — see
`.env.example` for what each one is and where it comes from. `AUTH_SECRET_KEY`
is **required in production**: without it the API uses a random per-process
key, so logins reset on restart. The `OKTA_*` variables are not a hard-fail the
same way — the API starts without them, it just refuses every sign-in and says
so in the startup log (`okta_auth.describe()`).
```bash
python -c "import secrets; print(secrets.token_urlsafe(48))"
```
The Okta app integration itself (sign-in method OIDC, Application type Web
Application) needs its **Sign-in redirect URI** set to exactly
`OKTA_REDIRECT_URI`'s value, and the people who should have access assigned to
it — that assignment IS the access control (see above).
### Create the first admin
The `/api/auth/users` endpoint needs an existing admin, so bootstrap one from a
shell (run from the **project root**, like uvicorn):
There's no `create-admin` command anymore — creating an account from scratch
by hand-typed username risks a second, orphaned row if it doesn't exactly match
what Okta actually sends (see `OKTA_IDENTITY_CLAIM` in `.env.example`). Instead,
have the first admin **sign in through Okta once** — they land as an ordinary
`project_user`, JIT-provisioned — then promote that existing row from a shell
(run from the **project root**, like uvicorn):
```bash
python -m server.manage_users create-admin alice --name "Alice Smith"
# prompts for a password (min 8 chars)
python -m server.manage_users promote alice --role admin
```
In Docker:
```bash
docker compose exec api python -m server.manage_users create-admin alice --name "Alice Smith"
docker compose exec api python -m server.manage_users promote alice --role admin
```
Other commands: `create <user> --role user`, `list`, `reset-password <user>`,
`disable <user>`, `enable <user>`. After that, admins can add users through the
API (or you can keep using the CLI).
Other commands: `list`, `disable <user>`, `enable <user>`. After the first
admin exists, they can promote others through the User Directory page (or keep
using the CLI) — no shell access needed for anyone after the first.
**No break-glass path.** If Okta is unreachable or misconfigured, the app is
unreachable for everyone, including admins, until Okta is restored (D16) — this
is a deliberate choice, the same one the abandoned LDAPS design made, not an
oversight.
---
@@ -291,25 +322,25 @@ docker compose down -v
## Quick test
`/api/health` is open; data routes now require a session, so log in first and
reuse the cookie jar:
`/api/health` is open; every other `/api/` route needs a session cookie:
```bash
curl http://127.0.0.1:8000/api/health # {"ok":true} — no auth needed
# Sign in, saving the session cookie to a jar
curl -c jar.txt -X POST http://127.0.0.1:8000/api/auth/login \
-H 'Content-Type: application/json' \
-d '{"username":"alice","password":"<password>"}'
# Reuse the cookie on protected routes
curl -b jar.txt http://127.0.0.1:8000/api/comments
```
Without the cookie, protected routes return `401 {"detail":"Not authenticated"}`.
Without a session cookie, protected routes return `401 {"detail":"Not authenticated"}`.
Or via the nginx proxy (replace with your hostname):
```bash
curl https://wp-suite.company.local/api/health
```
There's no `curl`-able login anymore — Okta requires a real browser to
complete, which is what `login.html`'s "Sign in with Okta" button is for. To
exercise a protected route from a script instead, use `server/smoketest.py`'s
own technique (mint a session with `auth.create_token()` and set it as the
`wp_session` cookie, the same thing `okta_callback()` does after Okta hands
back an identity) rather than reaching for curl by hand — see that script's
own AUTHENTICATION section for the exact steps, and why it has to run
somewhere that shares the target server's `AUTH_SECRET_KEY` and database.

View File

@@ -52,6 +52,13 @@ def run_migrations_online() -> None:
connection=connection,
target_metadata=target_metadata,
compare_type=True,
# Each migration commits on its own. One transaction for the WHOLE
# run meant a crash at step N rolled back steps 1..N-1 while their
# "Running upgrade" lines stayed on screen claiming they ran - the
# 2026-08-21 outage's stamp-to-head repair trusted those lines and
# left production missing two tables (found 2026-08-23 when the
# locations import 500'd on a table that "had been created").
transaction_per_migration=True,
)
with context.begin_transaction():
context.run_migrations()

View File

@@ -0,0 +1,29 @@
"""drop local password (T10.4, wave 10 / D15 / D16)
Real deletion, not a toggle: no local password exists anymore, only Okta OIDC.
`password_hash` was NOT NULL at the database level since the baseline schema, so
downgrade re-adds it with server_default='' rather than leaving existing rows
without a value — the same pattern used for the locale/timezone drop-precedent
columns, applied in reverse.
Revision ID: 1d60a608bb51
Revises: a1b8c6d4e2f9
Create Date: 2026-09-03 00:00:00.000000
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = '1d60a608bb51'
down_revision = 'a1b8c6d4e2f9'
branch_labels = None
depends_on = None
def upgrade() -> None:
op.drop_column('users', 'password_hash')
def downgrade() -> None:
op.add_column('users', sa.Column('password_hash', sa.String(length=200), nullable=False, server_default=''))

View File

@@ -0,0 +1,46 @@
"""usage events (CR-019, wave 11)
Append-only navigation/session activity, separate from audit_log on purpose —
see the UsageEvent docstring in server/models.py. Retention is indefinite by
decision (docs/waves/decisions-2026-09-17.md); nothing here schedules a purge.
Revision ID: 8e2cb3003f8a
Revises: 1d60a608bb51
Create Date: 2026-09-23 00:00:00.000000
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = '8e2cb3003f8a'
down_revision = '1d60a608bb51'
branch_labels = None
depends_on = None
def upgrade() -> None:
op.create_table('usage_events',
sa.Column('id', sa.String(length=40), nullable=False),
sa.Column('at', sa.DateTime(timezone=True), nullable=False),
sa.Column('username', sa.String(length=200), nullable=False),
sa.Column('project_id', sa.String(length=40), nullable=True),
sa.Column('tool', sa.String(length=40), nullable=False),
sa.Column('event', sa.String(length=40), nullable=False),
sa.Column('detail', sa.JSON(), nullable=False),
sa.PrimaryKeyConstraint('id')
)
op.create_index(op.f('ix_usage_events_at'), 'usage_events', ['at'], unique=False)
op.create_index(op.f('ix_usage_events_username'), 'usage_events', ['username'], unique=False)
op.create_index(op.f('ix_usage_events_project_id'), 'usage_events', ['project_id'], unique=False)
op.create_index(op.f('ix_usage_events_tool'), 'usage_events', ['tool'], unique=False)
op.create_index(op.f('ix_usage_events_event'), 'usage_events', ['event'], unique=False)
def downgrade() -> None:
op.drop_index(op.f('ix_usage_events_event'), table_name='usage_events')
op.drop_index(op.f('ix_usage_events_tool'), table_name='usage_events')
op.drop_index(op.f('ix_usage_events_project_id'), table_name='usage_events')
op.drop_index(op.f('ix_usage_events_username'), table_name='usage_events')
op.drop_index(op.f('ix_usage_events_at'), table_name='usage_events')
op.drop_table('usage_events')

File diff suppressed because it is too large Load Diff

View File

@@ -1,10 +1,11 @@
"""Authentication for the Work Package Suite.
A self-contained username/password login. Passwords are stored only as bcrypt
hashes; a successful login issues a signed JWT that rides in an HttpOnly cookie
(`wp_session`). Because the token is signed and self-validating, there is no
server-side session store — every request is checked by verifying the cookie's
signature and expiry (see `auth_gate` and `get_current_user`).
Identity is confirmed by Okta (OIDC authorization-code flow, see server/okta_auth.py
and the routes in server/app.py); there is no local password anywhere in this app
(D15, D16 — T10.4 removed the last of it). A successful sign-in issues a signed JWT
that rides in an HttpOnly cookie (`wp_session`). Because the token is signed and
self-validating, there is no server-side session store — every request is checked by
verifying the cookie's signature and expiry (see `auth_gate` and `get_current_user`).
Security model:
• The real boundary is `auth_gate` (middleware in app.py): every /api/ data
@@ -17,7 +18,9 @@ Security model:
warning and invalidates every session on restart) so dev still works.
Permissions roles (`User.role`) — distinct from a person's job function on the
project, which lives in `User.project_role` and grants nothing:
project, which lives in `User.project_role` and grants nothing. Decided entirely
locally: Okta gates WHO can authenticate at all, this app decides what an
authenticated account may do — see D15/D16.
• admin application administrator: user administration, app settings,
and implicit access to every project.
• project_super_user
@@ -30,15 +33,13 @@ project, which lives in `User.project_role` and grants nothing:
modify a SOP after it has been completed, and delete projects.
• project_user normal member: creates and edits work packages, authors a SOP
up to completion. May NOT delete WPs or change a completed SOP.
Also where Okta JIT provisioning (T10.3) lands a brand-new
account — the lowest-privilege role, promoted locally from
there by an admin (see manage_users.py for the bootstrap case).
The user-administration SCOPE of a super user is worked out in server/app.py
(`managed_project_ids`, `manage_user_problem`), because it depends on project
membership rows — this module only decides which roles carry the power at all.
Password reset: a short-lived signed token (see `create_reset_token`) is emailed
to the account's address. It is single-use by construction — it embeds the user's
`token_version`, which is bumped when the password changes, so a used or
superseded link stops validating.
"""
import os
import secrets
@@ -46,7 +47,6 @@ import logging
from datetime import datetime, timedelta, timezone
from typing import Optional
import bcrypt
import jwt
from fastapi import Depends, HTTPException, Request, Response, status
from sqlalchemy import select, func
@@ -59,10 +59,10 @@ log = logging.getLogger("wpsuite.auth")
COOKIE_NAME = "wp_session"
JWT_ALG = "HS256"
# How long a login lasts before the user must sign in again.
SESSION_HOURS = int(os.getenv("AUTH_SESSION_HOURS", "12"))
# How long an emailed password-reset link stays valid.
RESET_MINUTES = int(os.getenv("AUTH_RESET_MINUTES", "60"))
# How long a session lasts before the person must sign in again. Default 8 hours (D25).
# One flat limit from the moment of sign-in. When T13.1 lands, the same variable becomes
# the absolute ceiling and an idle timer is added under it.
SESSION_HOURS = int(os.getenv("AUTH_SESSION_HOURS", "8"))
# ── permissions roles ─────────────────────────────────────────────────────────
ROLE_ADMIN = "admin"
@@ -121,30 +121,7 @@ def is_project_admin(user: "models.User") -> bool:
# same question used to exist here and silently disagreed with the scoped one, which
# locked per-project super users out of the routes they were entitled to.
# Password policy (shared by the API and the CLI).
MIN_PASSWORD_LEN = int(os.getenv("AUTH_MIN_PASSWORD_LEN", "12"))
_COMMON_PASSWORDS = {
"password", "password1", "password123", "passw0rd", "12345678", "123456789",
"1234567890", "qwerty123", "letmein123", "changeme", "admin123", "welcome123",
"iloveyou1", "abc12345", "qwertyuiop",
}
def password_problem(pw: str, username: str = "", email: str = "") -> Optional[str]:
"""Return a human-readable reason the password is unacceptable, or None if OK.
Shared by the API endpoints and the CLI so the policy is enforced everywhere."""
if len(pw) < MIN_PASSWORD_LEN:
return f"Password must be at least {MIN_PASSWORD_LEN} characters."
low = pw.lower()
if username and low == username.strip().lower():
return "Password must not be the same as the username."
if email and low == email.strip().lower():
return "Password must not be the same as the email."
if low in _COMMON_PASSWORDS:
return "That password is too common — choose something less guessable."
return None
# Paths under /api that do NOT require a session (login itself, health, docs).
# Paths under /api that do NOT require a session (the Okta routes themselves, health, docs).
_EXEMPT_PREFIXES = ("/api/auth/",)
_EXEMPT_EXACT = {
"/api/health",
@@ -184,22 +161,6 @@ def _load_secret() -> str:
SECRET_KEY = _load_secret()
# ── password hashing ──────────────────────────────────────────────────────────
def hash_password(plain: str) -> str:
# bcrypt operates on at most 72 bytes; longer inputs are truncated by the
# algorithm. Encode explicitly so non-ASCII passwords hash consistently.
return bcrypt.hashpw(plain.encode("utf-8")[:72], bcrypt.gensalt()).decode("ascii")
def verify_password(plain: str, hashed: str) -> bool:
if not hashed:
return False
try:
return bcrypt.checkpw(plain.encode("utf-8")[:72], hashed.encode("ascii"))
except (ValueError, TypeError):
return False
# ── tokens ──────────────────────────────────────────────────────────────────
def create_token(user: "models.User") -> str:
now = datetime.now(timezone.utc)
@@ -214,46 +175,38 @@ def create_token(user: "models.User") -> str:
return jwt.encode(payload, SECRET_KEY, algorithm=JWT_ALG)
# D21: a real session token is about 300 characters. Anything far larger is not
# one of ours, and refusing it before parsing keeps a crafted cookie from making
# the parser do work on our behalf.
_MAX_TOKEN_CHARS = 4096
def decode_token(token: str) -> Optional[dict]:
"""Return the token claims if the signature and expiry are valid, else None.
Session cookies only — a token of any other type is rejected."""
try:
claims = jwt.decode(token, SECRET_KEY, algorithms=[JWT_ALG])
except jwt.PyJWTError:
Session cookies only — a token of any other type is rejected.
D21: fails CLOSED on any error. This used to catch jwt.PyJWTError only, and
PyJWT 2.13.0 let a RecursionError out of header parsing, so a 1.6 KB cookie
from someone with no account produced a 500 and a stack trace instead of a
401 (security review SEC-07). Whatever goes wrong inside the decoder, the
answer is the same: not signed in."""
if not token or len(token) > _MAX_TOKEN_CHARS:
return None
# A password-reset token must never be usable as a session cookie.
try:
# Every token this app issues carries exp and sub (create_token); one without them is not ours.
claims = jwt.decode(token, SECRET_KEY, algorithms=[JWT_ALG],
options={"require": ["exp", "sub"]})
except Exception: # noqa: BLE001 — see docstring: every failure is "not signed in"
return None
# No route issues a `typ`-carrying token anymore (that was the password-reset
# token, removed in T10.4), but a session token still must never validate as
# one — kept as a defensive check, cheap insurance against a future token type
# riding the same cookie.
if claims.get("typ"):
return None
return claims
def create_reset_token(user: "models.User") -> str:
"""Short-lived, single-use token for an emailed password-reset link.
Single-use falls out of `ver`: completing a reset bumps the user's
token_version, so the link (and any older link) no longer validates."""
now = datetime.now(timezone.utc)
payload = {
"typ": "pwreset",
"sub": user.id,
"ver": user.token_version or 0,
"iat": now,
"exp": now + timedelta(minutes=RESET_MINUTES),
}
return jwt.encode(payload, SECRET_KEY, algorithm=JWT_ALG)
def decode_reset_token(token: str) -> Optional[dict]:
"""Claims for a valid, unexpired reset token, else None."""
try:
claims = jwt.decode(token, SECRET_KEY, algorithms=[JWT_ALG])
except jwt.PyJWTError:
return None
if claims.get("typ") != "pwreset":
return None
return claims
# ── cookie helpers ────────────────────────────────────────────────────────────
def _is_https(request: Request) -> bool:
# Behind NGINX, TLS is terminated at the proxy and forwarded as plain HTTP,

66
server/files_http.py Normal file
View File

@@ -0,0 +1,66 @@
"""Safe HTTP responses for uploaded drawings — D19 (T16.2).
Security review 2026-10-01, SEC-01 and SEC-15e.
WHY THIS EXISTS
Uploads accept `image/*`, which includes `image/svg+xml`. An SVG is a
document, not a picture: it can carry <script>. GET /api/files/{id} used to
return every file `inline` with the uploader's content type, on the app's own
origin, so a script inside an SVG ran as whoever opened the drawing - with
their session, and with an admin's power if an admin opened it.
The download name was built by hand with only `"` removed. A name outside
Latin-1 (`Plan é.pdf`) made the header unencodable, so the download failed
with 500; CR/LF in a name went into the header as typed.
THE RULE (D19, decided 2026-10-02)
* PDF and raster images open INLINE, exactly as before. That is what the
creator's drawing list, the printed package and Field View link to
(CR-007), and the offline drawing cache in sw.js stores.
* Every other type, SVG included, is an ATTACHMENT inside a sandbox: the
browser saves it instead of rendering it on our origin, and
`Content-Security-Policy: sandbox` strips script and same-origin access
even if someone opens the saved response directly.
* SVG UPLOADS STAY ACCEPTED (decided: accept, download only). The fix is on
the way out, so SVGs already in the database are covered too.
* `Cache-Control` is unchanged - the offline drawing cache depends on it.
"""
from __future__ import annotations
import re
from urllib.parse import quote
from fastapi.responses import Response
# Formats a browser shows as inert pixels, or in its own PDF viewer.
INLINE_SAFE_MIME = frozenset({
"application/pdf",
"image/png", "image/jpeg", "image/gif", "image/webp", "image/bmp", "image/avif",
})
# Control characters, and the characters that end or escape a quoted
# header parameter. Replaced, never passed through.
_UNSAFE_NAME = re.compile(r'[\x00-\x1f\x7f"\\;]')
def content_disposition(disposition: str, name: str) -> str:
"""A header value that is valid for ANY user-supplied file name: an ASCII
fallback for old clients plus RFC 5987 `filename*` with the real name."""
name = _UNSAFE_NAME.sub("_", name or "file").strip() or "file"
ascii_name = name.encode("ascii", "replace").decode("ascii").replace("?", "_")
return f"{disposition}; filename=\"{ascii_name}\"; filename*=UTF-8''{quote(name, safe='')}"
def file_response(row) -> Response:
"""The response for GET /api/files/{id}. `row` is a models.WpFile."""
mime = (row.mime or "application/octet-stream").lower()
headers = {
"Cache-Control": "private, max-age=86400", # unchanged: sw.js caches drawings offline
"X-Content-Type-Options": "nosniff", # NGINX adds it too; the dev server did not
}
if mime in INLINE_SAFE_MIME:
headers["Content-Disposition"] = content_disposition("inline", row.name)
else:
headers["Content-Disposition"] = content_disposition("attachment", row.name)
headers["Content-Security-Policy"] = "sandbox; default-src 'none'"
return Response(content=row.data, media_type=mime, headers=headers)

View File

@@ -1,24 +1,28 @@
"""Command-line user management for the Work Package Suite.
Use this to create the FIRST admin account (the /api/auth/users endpoint needs an
existing admin, so you have to bootstrap one here), and for occasional account
There is no local password (D15) and no local account creation from here anymore
(D16, T10.4) — accounts are created by signing in through Okta, which JIT-
provisions a row at the lowest-privilege role (see server/okta_auth.py,
server/app.py's okta_callback(), wave-10.md T10.3). This tool's job is narrower
now: change the role on an account that already exists, and do routine account
maintenance from a shell on the server.
That narrower job is still how the very first admin gets named (D16): have that
person sign in through Okta once — they land as project_user — then promote them
from here. Promoting an existing row, rather than creating one blind, matters
because it never has to guess the exact string Okta will send as the identity
claim; a hand-typed username that doesn't match it exactly would just produce a
second, orphaned account instead of the one you meant to promote.
Run from the PROJECT ROOT (same place you run uvicorn), so the package imports
and .env resolve the same way the API does:
python -m server.manage_users create-admin alice --name "Alice Smith"
python -m server.manage_users create bob --role user --name "Bob Jones"
python -m server.manage_users promote alice --role admin
python -m server.manage_users list
python -m server.manage_users reset-password alice
python -m server.manage_users disable bob
python -m server.manage_users enable bob
If --password is omitted you'll be prompted (input is hidden). Passwords must be
at least 8 characters.
"""
import argparse
import getpass
import sys
import uuid
@@ -26,53 +30,48 @@ from .db import SessionLocal, Base, engine
from . import models, auth
def _gen_id() -> str:
return f"user_{uuid.uuid4().hex[:12]}"
def _prompt_password(provided: str | None, username: str = "") -> str:
pw = provided
if not pw:
pw = getpass.getpass("New password: ")
confirm = getpass.getpass("Confirm password: ")
if pw != confirm:
sys.exit("Passwords do not match.")
problem = auth.password_problem(pw, username)
if problem:
sys.exit(problem)
return pw
def cmd_create(args, role: str | None = None) -> None:
role = role or args.role
# 'user' is the pre-roles spelling of 'project_user' and is still accepted so the
# documented one-liners keep working; anything else has to be a current role.
def cmd_promote(args) -> None:
role = args.role
# 'user' is the pre-roles spelling of 'project_user', accepted here so a
# documented one-liner from before this rework keeps working.
if role == "user":
role = auth.ROLE_PROJECT_USER
if role not in auth.ROLES:
sys.exit(f"role must be one of {', '.join(auth.ROLES)}")
pw = _prompt_password(getattr(args, "password", None), args.username)
with SessionLocal() as db:
if auth.find_user(db, args.username):
sys.exit(f"A user named '{args.username}' already exists.")
u = models.User(
id=_gen_id(),
username=args.username.strip(),
full_name=(args.name or "").strip(),
email=(args.email or "").strip(),
password_hash=auth.hash_password(pw),
role=role,
)
db.add(u)
u = auth.find_user(db, args.username)
if not u:
sys.exit(
f"No user named '{args.username}'. This promotes an existing account, it "
f"doesn't create one — they need to sign in through Okta at least once first."
)
old_role = u.role
u.role = role
# Audited the same way a role change from the web Admin Console already is
# (server/app.py's set_user_role() -> log_event(), action "role_changed") —
# this command changes the same field and previously left no record of who
# ran it or what it changed (T10.10). "actor" can't name a real person here:
# a container shell exec carries no signed-in identity to attribute it to,
# so it's tagged as the tool itself rather than guessing. "via" mirrors JIT
# provisioning's own tag on user_created events.
db.add(models.AuditLog(
id=f"ev_{uuid.uuid4().hex[:12]}",
actor="cli:manage_users",
action="role_changed",
entity_type="user",
entity_id=u.id,
summary=u.username,
detail={"from": old_role, "to": role, "via": "cli"},
))
db.commit()
print(f"Created {role}: {u.username} (id={u.id})")
print(f"{u.username} is now {auth.ROLE_LABELS.get(role, role)}.")
def cmd_list(args) -> None:
with SessionLocal() as db:
rows = db.query(models.User).order_by(models.User.username).all()
if not rows:
print("No users yet. Create one with: create-admin <username>")
print("No users yet. Accounts appear here once someone signs in through Okta.")
return
print(f"{'USERNAME':<24}{'ROLE':<20}{'ACTIVE':<8}{'NAME'}")
for u in rows:
@@ -80,17 +79,6 @@ def cmd_list(args) -> None:
f"{('yes' if u.is_active else 'no'):<8}{u.full_name}")
def cmd_reset_password(args) -> None:
pw = _prompt_password(getattr(args, "password", None), args.username)
with SessionLocal() as db:
u = auth.find_user(db, args.username)
if not u:
sys.exit(f"No user named '{args.username}'.")
u.password_hash = auth.hash_password(pw)
db.commit()
print(f"Password reset for {u.username}.")
def _set_active(username: str, active: bool) -> None:
with SessionLocal() as db:
u = auth.find_user(db, username)
@@ -108,39 +96,23 @@ def main() -> None:
p = argparse.ArgumentParser(prog="manage_users", description="Work Package Suite user management")
sub = p.add_subparsers(dest="cmd", required=True)
def add_create(name, help_):
sp = sub.add_parser(name, help=help_)
sp.add_argument("username")
sp.add_argument("--password", help="set non-interactively (otherwise prompted)")
sp.add_argument("--name", default="", help="full name")
sp.add_argument("--email", default="")
return sp
add_create("create-admin", "create an admin account")
c = add_create("create", "create an account")
c.add_argument("--role", choices=list(auth.ROLES) + ["user"], default=auth.ROLE_PROJECT_USER,
help="permissions role ('user' is the legacy name for project_user)")
pr = sub.add_parser("promote", help="change an existing account's role (e.g. name the first admin)")
pr.add_argument("username")
pr.add_argument("--role", required=True, choices=list(auth.ROLES) + ["user"],
help="permissions role ('user' is the legacy name for project_user)")
sub.add_parser("list", help="list all accounts")
rp = sub.add_parser("reset-password", help="reset a user's password")
rp.add_argument("username")
rp.add_argument("--password", help="set non-interactively (otherwise prompted)")
dp = sub.add_parser("disable", help="disable an account (blocks login)")
dp = sub.add_parser("disable", help="disable an account (blocks sign-in)")
dp.add_argument("username")
ep = sub.add_parser("enable", help="re-enable an account")
ep.add_argument("username")
args = p.parse_args()
if args.cmd == "create-admin":
cmd_create(args, role="admin")
elif args.cmd == "create":
cmd_create(args)
if args.cmd == "promote":
cmd_promote(args)
elif args.cmd == "list":
cmd_list(args)
elif args.cmd == "reset-password":
cmd_reset_password(args)
elif args.cmd == "disable":
_set_active(args.username, False)
elif args.cmd == "enable":

View File

@@ -142,8 +142,10 @@ class WorkPackage(Base):
class User(Base):
"""A login account. Passwords are never stored in the clear — only a bcrypt
hash (see server/auth.py). `username` is what people sign in with.
"""A login account. No password is stored here or anywhere else — identity is
confirmed by Okta (OIDC), this app only decides what the account may do once
Okta has vouched for it (see server/okta_auth.py, server/auth.py, D15/D16).
`username` is what Okta's identity claim resolves to.
Two independent notions of "role", deliberately separate:
• role the PERMISSIONS role — what the account may do in the app.
@@ -159,7 +161,6 @@ class User(Base):
username: Mapped[str] = mapped_column(String(120), unique=True, index=True)
email: Mapped[str] = mapped_column(String(200), default="")
full_name: Mapped[str] = mapped_column(String(200), default="")
password_hash: Mapped[str] = mapped_column(String(200), default="")
role: Mapped[str] = mapped_column(String(20), default="project_user") # permissions role
# Job function on the project — free text, offered from a suggested list.
project_role: Mapped[str] = mapped_column(String(120), default="")
@@ -336,6 +337,45 @@ class AuditLog(Base):
}
class UsageEvent(Base):
"""CR-019: append-only record of who used the suite, when, and which tool —
navigation/session activity, not business mutations. Deliberately a SEPARATE
table from AuditLog rather than a new `action` value there: AuditLog answers
"who changed what" and is read by people auditing a specific record's
history; mixing in a `page_open` row for every authenticated page load
would make that trail noisy for its existing purpose. This table answers a
different question — "who is active, and on what" — and CR-019's admin
console reads from here, not from AuditLog.
Not a ForeignKey to `users`, matching AuditLog's own reasoning: a user who
is later removed should still show up in historical activity rather than
silently vanishing from it, and `D18`'s deprovisioning sync only ever sets
`is_active=False` — it never deletes a row — so this is defensive symmetry
rather than a live concern today.
Retention is indefinite (decided 2026-09-17, `decisions-2026-09-17.md`) —
nothing purges rows written here; that is a deliberate product decision,
not an oversight to fix later."""
__tablename__ = "usage_events"
id: Mapped[str] = mapped_column(String(40), primary_key=True)
at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=utcnow, index=True)
username: Mapped[str] = mapped_column(String(200), default="", index=True)
project_id: Mapped[Optional[str]] = mapped_column(String(40), nullable=True, index=True)
# creator | wizard | field_view | dashboard | admin | directory | ...
tool: Mapped[str] = mapped_column(String(40), default="", index=True)
# page_open | login
event: Mapped[str] = mapped_column(String(40), default="", index=True)
detail: Mapped[dict] = mapped_column(JSON, default=dict)
def to_dict(self) -> dict:
return {
"id": self.id, "at": _iso(self.at), "username": self.username,
"project_id": self.project_id, "tool": self.tool, "event": self.event,
"detail": self.detail or {},
}
class AppSetting(Base):
"""Admin-editable application settings (feature flags, SMTP config, …) stored
as key -> JSON value. Read/written via /api/settings (admin only). Secrets like

109
server/okta_auth.py Normal file
View File

@@ -0,0 +1,109 @@
"""Okta OIDC client configuration — T10.1, wave 10 (D15).
This module owns the conversation with Okta and nothing else: it does not issue this
app's own session cookie, does not touch the database, and does not decide who may sign
in. `server/auth.py` keeps doing all of that, unchanged — a session is still a signed JWT
in an HttpOnly cookie, roles are still local, `get_current_user` still re-reads the
account on every request. Only how a person's identity gets confirmed changes: an Okta
authorization-code flow, in place of the local username/password check.
Access gating is Okta's job, not this module's. Only accounts assigned to this app
integration in Okta ever complete the flow at all, so there is no required-group or
claim check layered on top here — see D15 and wave-10.md for why that is a deliberate
difference from D13's design, not an oversight.
Unconfigured is a first-class state, same discipline as the LDAPS module this replaces:
with any of the four settings below missing, `is_configured()` is False and `describe()`
says so in the startup log, rather than the app discovering it later at the login button.
"""
import logging
import os
from typing import Optional
log = logging.getLogger("wpsuite.okta")
try:
from authlib.integrations.starlette_client import OAuth
HAVE_AUTHLIB = True
except ImportError: # pragma: no cover
HAVE_AUTHLIB = False
OAuth = None # type: ignore[assignment]
# ── configuration ─────────────────────────────────────────────────────────────
# The Okta *authorization server* issuer, e.g. https://primecontrols.okta.com/oauth2/default
# or a custom authorization server URL. Authlib discovers the rest (authorize/token/
# jwks endpoints) from `<issuer>/.well-known/openid-configuration` — nothing below is
# hand-entered except this base URL, the client credentials, and our own callback.
ISSUER = os.getenv("OKTA_ISSUER", "")
CLIENT_ID = os.getenv("OKTA_CLIENT_ID", "")
CLIENT_SECRET = os.getenv("OKTA_CLIENT_SECRET", "")
# Must exactly match a Sign-in redirect URI registered on the Okta app integration.
# e.g. https://wp.controls.dev/api/auth/okta/callback
REDIRECT_URI = os.getenv("OKTA_REDIRECT_URI", "")
# Standard OIDC identity scopes only. No group/role scopes: T10.2's note above explains
# why access gating and permissions both stay out of the token.
SCOPES = "openid profile email"
# Which claim in the ID token carries this person's AD sAMAccountName equivalent, for
# matching against the local `users` table (T10.3). Not yet confirmed by security —
# `preferred_username` is Okta's usual default for an AD-imported user, used here as a
# documented placeholder, NOT a verified answer. Override via env once security replies
# so the real value can drop in without a code change.
IDENTITY_CLAIM = os.getenv("OKTA_IDENTITY_CLAIM", "preferred_username")
def is_configured() -> bool:
"""Whether an OIDC flow could even be attempted. Deliberately does not touch the
network — that would be a `selftest()`, added when T10.2 needs one."""
return bool(HAVE_AUTHLIB and ISSUER and CLIENT_ID and CLIENT_SECRET and REDIRECT_URI)
def describe() -> str:
"""One line for the startup log, matching the LDAPS module's discipline: an
unconfigured deploy must be visible in `docker compose logs api`, not discovered at
the login button."""
from . import okta_fake
if okta_fake.is_active():
return (f"*** FAKE OKTA PROVIDER ACTIVE — identities come from "
f"{okta_fake.ENV_VAR}, NOT from Okta. Tests only. ***")
if not HAVE_AUTHLIB:
return "Okta auth DISABLED — authlib is not installed. No one can sign in."
missing = [name for name, val in (
("OKTA_ISSUER", ISSUER), ("OKTA_CLIENT_ID", CLIENT_ID),
("OKTA_CLIENT_SECRET", CLIENT_SECRET), ("OKTA_REDIRECT_URI", REDIRECT_URI),
) if not val]
if missing:
return f"Okta auth DISABLED — missing {', '.join(missing)}. No one can sign in."
return (f"Okta auth enabled — issuer {ISSUER}, redirect {REDIRECT_URI}, "
f"identity claim {IDENTITY_CLAIM!r}")
def _build_oauth():
"""Register the Okta client. Returns None when unconfigured so the caller (T10.2's
routes) can fail loudly instead of Authlib raising deep inside a request.
Checked before `is_configured()`: the fake (T10.7) needs none of the four real
Okta settings, and must win whenever it is legitimately active so a test run
never has to also fill in placeholder OKTA_ISSUER/CLIENT_ID/etc. `is_active()`
already refuses outside a SQLite-backed test database — see okta_fake.py."""
from . import okta_fake
if okta_fake.is_active():
log.warning("*** FAKE OKTA PROVIDER ACTIVE (%s) — tests only ***", okta_fake.ENV_VAR)
return okta_fake.build()
if not is_configured():
return None
oauth = OAuth()
oauth.register(
name="okta",
client_id=CLIENT_ID,
client_secret=CLIENT_SECRET,
server_metadata_url=f"{ISSUER.rstrip('/')}/.well-known/openid-configuration",
client_kwargs={"scope": SCOPES},
)
return oauth
# Built once at import time, same as `SECRET_KEY` in auth.py — a missing/bad config is a
# deploy problem to catch at startup via `describe()`, not a per-request surprise.
oauth = _build_oauth()

190
server/okta_fake.py Normal file
View File

@@ -0,0 +1,190 @@
"""A fake Okta, for tests only — T10.7.
`server/okta_auth.py` normally hands the browser off to a real Okta authorize
endpoint and exchanges the code with Okta's token endpoint over the network
(Authlib discovers both from `<issuer>/.well-known/openid-configuration`). Tests
cannot reach any of that: there is no live Okta tenant in CI, and the browser
checks launch the app as a SUBPROCESS (`start_server` in tests/browser_check.py),
so a monkeypatch in the test process would never reach the code doing the
authenticating. The seam has to be configurable from the ENVIRONMENT — same
discipline as `server/ldap_fake.py`, D13/T10.7's LDAP predecessor.
Set `WP_OKTA_FAKE_DIRECTORY` to a JSON object and this module stands in for the
whole round trip — the authorize redirect, a stand-in "sign in at Okta" screen,
and the token exchange — with no network call anywhere:
{"root": {"email": "root@example.test", "name": "Root Person"}}
The key is the identity value a real Okta ID token would carry in whichever
claim `OKTA_IDENTITY_CLAIM` names (default `preferred_username`) — the fake
reads `okta_auth.IDENTITY_CLAIM` at request time, so it exercises whatever claim
name is actually configured rather than a hard-coded one.
WHAT THIS DOES AND DOES NOT REPLACE
Only the OAuth-protocol plumbing that talks to Okta over the network is faked —
`authorize_redirect` and `authorize_access_token`, both owned by Authlib, a
third-party library, not this app's security logic. Everything this app itself
decides stays real and untouched in `app.py`'s `okta_login()`/`okta_callback()`:
the `?next=` open-redirect guard (`_safe_next_path`), the disabled-account
check, JIT provisioning, and which claim carries identity. A fake run exercises
the actual code for all of that, not a re-implementation of it — the same
boundary `ldap_fake.py` drew around the anonymous-bind guard.
THE PRODUCTION GUARD IS THE POINT OF THIS FILE.
An environment variable that lets anyone "sign in" as any identity by visiting a
picker page is exactly the kind of thing that must never be reachable outside a
test process — D16 leaves no local password fallback and no break-glass, so a
fake provider silently active in production would be a total authentication
bypass with a friendlier UI than most. `is_active()` refuses whenever a real
database is configured, using the same test `auth._load_secret` and
`ldap_fake.is_active()` already use: a non-SQLite `DATABASE_URL` means
production, full stop. `okta_auth.describe()` also shouts when the fake is
live, and `app.py` registers the picker/consent routes only when the fake is
active at import time — in production they do not exist, not merely refuse.
"""
import json
import logging
import os
import secrets
import time
from html import escape
from typing import Optional
from urllib.parse import quote
from starlette.responses import RedirectResponse
log = logging.getLogger("wpsuite.okta.fake")
ENV_VAR = "WP_OKTA_FAKE_DIRECTORY"
# One-time authorization codes, in-process only. The login and the callback that
# redeems the code both happen inside the SAME uvicorn process within one test
# run, so this needs no more durability than that — the server restart every
# check does between runs clears it for free. Not a cache: entries are popped on
# first use (below) and expire on their own otherwise.
_CODE_TTL_SECONDS = 120
_PENDING_CODES: dict = {}
def _raw() -> str:
return os.getenv(ENV_VAR, "").strip()
def is_active() -> bool:
"""Whether the fake should answer. False in anything resembling production."""
if not _raw():
return False
# Imported lazily: server.db reads DATABASE_URL at import, and this module is
# imported from okta_auth (and app.py), which must stay importable on its own.
from .db import DATABASE_URL
if not str(DATABASE_URL).startswith("sqlite"):
log.error(
"%s is set but a non-SQLite DATABASE_URL is configured. REFUSING to use "
"the fake Okta provider — this looks like production, and D16 leaves no "
"other way in, so honouring it would be an authentication bypass. "
"Unset %s.", ENV_VAR, ENV_VAR)
return False
return True
def directory() -> dict:
try:
data = json.loads(_raw())
if not isinstance(data, dict):
raise ValueError("top level must be an object")
return data
except Exception as exc: # noqa: BLE001 — a malformed fake must not look auth-shaped
log.error("%s is not valid JSON (%s); the fake directory is empty", ENV_VAR, exc)
return {}
def new_code(claims: dict) -> str:
code = secrets.token_urlsafe(24)
_PENDING_CODES[code] = {"claims": claims, "expires": time.time() + _CODE_TTL_SECONDS}
return code
def consume_code(code: str) -> Optional[dict]:
"""Pop and return the claims for a code, or None if unknown/expired/reused.
Popping makes the code single-use, matching a real authorization code."""
entry = _PENDING_CODES.pop(code, None)
if not entry or entry["expires"] < time.time():
return None
return entry["claims"]
def picker_page(state: str, redirect_uri: str) -> str:
"""The fake's stand-in for Okta's own sign-in screen — a plain list of the
identities `WP_OKTA_FAKE_DIRECTORY` defines, so a browser check can click
through a real page rather than skip the round trip with a minted cookie.
Deliberately plain: nothing here is styled to resemble a real Okta page."""
from . import okta_auth
rows = []
for username in directory():
href = (f"/api/auth/okta/_fake_provider/consent?state={quote(state)}"
f"&redirect_uri={quote(redirect_uri, safe='')}&username={quote(username)}")
rows.append(
f'<li><a id="okta-fake-identity-{escape(username)}" href="{escape(href, quote=True)}">'
f'Continue as {escape(username)}</a></li>')
deny_href = (f"/api/auth/okta/_fake_provider/consent?state={quote(state)}"
f"&redirect_uri={quote(redirect_uri, safe='')}&deny=1")
deny_href = escape(deny_href, quote=True)
return (
"<!doctype html><title>FAKE Okta — tests only</title>"
"<h1>*** FAKE OKTA PROVIDER — TESTS ONLY ***</h1>"
f"<p>Identity claim in use: <code>{escape(okta_auth.IDENTITY_CLAIM)}</code></p>"
"<ul>" + "".join(rows) + "</ul>"
f'<p><a id="okta-fake-deny" href="{deny_href}">Deny access</a></p>'
)
class _FakeOktaClient:
"""Stands in for Authlib's `oauth.okta` — the same two methods `app.py`
calls, the same async signatures, zero network calls."""
async def authorize_redirect(self, request, redirect_uri):
state = secrets.token_urlsafe(24)
# The only session write this fake makes. authorize_access_token below is
# the only read — mirrors exactly what real Authlib does with `state`,
# which is what T10.2's missing-SessionMiddleware bug was about: this
# round trip is a genuine test of the same plumbing.
request.session["_okta_fake_state"] = state
target = redirect_uri or "/api/auth/okta/callback"
url = (f"/api/auth/okta/_fake_provider?state={quote(state)}"
f"&redirect_uri={quote(target, safe='')}")
return RedirectResponse(url=url, status_code=302)
async def authorize_access_token(self, request):
from authlib.integrations.base_client import OAuthError
expected = request.session.pop("_okta_fake_state", None)
given = request.query_params.get("state", "")
if not expected or given != expected:
raise OAuthError(
error="invalid_state",
description="fake Okta: state did not match the session (T10.7 seam)")
err = request.query_params.get("error")
if err:
raise OAuthError(
error=err,
description=request.query_params.get("error_description", "denied"))
code = request.query_params.get("code", "")
claims = consume_code(code)
if claims is None:
raise OAuthError(error="invalid_grant",
description="fake Okta: unknown or expired code")
return {"userinfo": claims}
class FakeOAuth:
"""Stands in for Authlib's `OAuth()` registry. The real one exposes each
registered client as an attribute by name; `app.py` only ever touches
`.okta`, so that is the only attribute this needs."""
def __init__(self):
self.okta = _FakeOktaClient()
def build() -> "FakeOAuth":
return FakeOAuth()

815
server/okta_sync.py Normal file
View File

@@ -0,0 +1,815 @@
"""Okta Management API client - T13.2, wave 13 (D18).
This module asks Okta one question: who is in the org, and what is each person's
status? It is the first half of the deprovisioning sync. It does not touch the
database and it does not disable anyone. T13.3 does that, using the list this
module returns.
Trust boundary. Sign-in uses the OIDC client (OKTA_CLIENT_ID and OKTA_CLIENT_SECRET,
see okta_auth.py). This module uses a different credential, OKTA_API_TOKEN, a
read-only Okta API token. The two never mix. A rotation or a leak of one does not
touch the other.
Failure rule (D18, decision 4). This is the most important rule in this file:
**an error is never an empty list.** If anything goes wrong, this module raises
OktaSyncError. It never returns [] to mean "the call failed". T13.3 reads an empty
list as "nobody is active", so a function that returned [] on a network error
would disable every account on an Okta outage. The cases that raise are:
- the token or the org URL is not set
- a network error or a timeout
- any HTTP status that is not 200 (401, 403 and 429 included)
- a body that is not a JSON list, or an item that is not shaped as expected
- a user with no usable identity value
- a list with no users at all (a real org is never empty; an empty list means
the token cannot see the users)
- a page limit reached (a cut-off list would make real users look missing)
- a "next page" link that points to a different host
T13.3 (the sync job, `run_sync` below) uses that list to disable local accounts.
Its rules are in its own docstring. In short: it only ever disables, it never
re-enables, it writes one audit row per change, and any failure means NO change.
The token is read from the environment each time it is used. It is never logged,
never put in an error message, and never returned to a browser. Errors carry the
exception class name and the HTTP status only. httpx exceptions can include the
request URL, so the URL is not copied into the message either.
"""
import base64
import hashlib
import json
import logging
import os
import re
import threading
import time
import uuid
from datetime import datetime, timedelta, timezone
from dataclasses import dataclass, field
from typing import Callable, Optional
from urllib.parse import urlparse
import httpx
import jwt
from cryptography.hazmat.primitives.asymmetric import ec
from sqlalchemy import select, update
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import Session
from . import models, okta_auth
log = logging.getLogger("wpsuite.okta_sync")
def _make_logs_visible() -> None:
"""Make this module's INFO lines reach `docker compose logs api`.
Nothing in this app configures Python logging, and gunicorn only configures its
own loggers. So the root logger sits at WARNING with no handler, and every
INFO line from a `wpsuite.*` logger is dropped. Found on 2026-10-16: with the
exact production launch command, `grep "Okta sync"` found nothing on a healthy
start, because "configured", "scheduled" and "done" are INFO lines. Warnings
and errors (a disable, a skipped run) showed, but the lines that say the sync
is alive did not. An operator cannot tell "off" from "on and quiet".
This adds one stderr handler to THIS module's logger only, and only when the
root logger has none, so it never doubles up if logging is configured later and
it does not change what any other module prints. (BL-028 and the general
question of app-wide logging are separate items.)"""
if log.handlers or logging.getLogger().handlers:
return
handler = logging.StreamHandler()
handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s"))
log.addHandler(handler)
log.setLevel(logging.INFO)
_make_logs_visible()
# Okta's own page maximum for this endpoint. Asking for the maximum keeps a
# 20-odd account org to a single call.
PAGE_LIMIT = 200
# A cut-off list is more dangerous than an error, so the loop is bounded and
# raises when the bound is reached. 50 pages of 200 is 10,000 people.
MAX_PAGES = 50
TIMEOUT_SECONDS = 15.0
# The whole fetch, all pages together, must finish inside this. T13.4 relies on it:
# a run is always shorter than the shortest allowed interval, so one cycle can
# never still be running when the next is due.
TOTAL_DEADLINE_SECONDS = 120.0
# Which Okta *profile attribute* matches each OIDC claim that OKTA_IDENTITY_CLAIM
# may name. The sign-in flow reads a claim from the ID token. This API returns
# the profile instead. For the default claim, preferred_username, Okta's own
# default maps it to profile.login. A claim that is not in this table is read
# from profile[<claim>] (for example a custom attribute).
# OKTA_SYNC_PROFILE_ATTRIBUTE overrides the whole table. Use it if the tenant
# builds the claim from a different attribute.
_CLAIM_TO_PROFILE = {
"preferred_username": "login",
"email": "email",
}
class OktaSyncError(Exception):
"""The Okta user list could not be fetched with confidence. T13.3 must take no
action on any account when it sees this."""
@dataclass(frozen=True)
class OktaUser:
identity: str # the value that matches users.username (lower case is NOT applied here)
status: str # Okta's status, upper case: ACTIVE, SUSPENDED, DEPROVISIONED, ...
# ── configuration ─────────────────────────────────────────────────────────────
def _token() -> str:
return os.getenv("OKTA_API_TOKEN", "").strip()
def org_url() -> str:
"""The Okta org base URL, for example https://yourorg.okta.com. The Management
API lives here, not at the authorization server issuer. OKTA_ORG_URL wins if
set. Otherwise it is the scheme and host of OKTA_ISSUER."""
explicit = os.getenv("OKTA_ORG_URL", "").strip().rstrip("/")
if explicit:
return explicit
issuer = (okta_auth.ISSUER or "").strip()
parsed = urlparse(issuer)
if parsed.scheme and parsed.netloc:
return f"{parsed.scheme}://{parsed.netloc}"
return ""
# D23: a second way to prove who we are to Okta. Okta apps of type "API Services"
# use OAuth 2.0 with client authentication private_key_jwt: this app holds a private
# key (a JWK), signs a short JWT with it, trades the JWT for a one-hour access token
# that carries only the scope okta.users.read, and sends that as a Bearer token. The
# private key never leaves this process. An SSWS API token (OKTA_API_TOKEN) still
# works and wins if both are set, so a deploy that has only a token behaves as before.
OAUTH_SCOPE = "okta.users.read"
ASSERTION_LIFETIME_SECONDS = 300
def _client_id() -> str:
return os.getenv("OKTA_SYNC_CLIENT_ID", "").strip()
def _key_raw() -> str:
return os.getenv("OKTA_SYNC_PRIVATE_KEY", "").strip()
def auth_method() -> str:
""""token" (SSWS API token), "oauth" (service app with a private key), or "" (none)."""
if _token():
return "token"
if _client_id() and _key_raw():
return "oauth"
return ""
def _parse_json_forgiving(text: str):
"""Parse the key text as JSON, forgiving what copying does to it. Returns
(object, None) or (None, "problem at line L column C: what"). The problem names a
position and a rule, never any text of the key. Forgiven: line breaks and other control
characters inside a string (a long value wrapped over several lines), curly quote
marks, and a comma before a closing brace. Spaces inside the key's own number fields
are removed, because those fields are base64 text."""
attempts = [text]
cleaned = (text.replace("\u201c", '"').replace("\u201d", '"').replace("\u2018", "'").replace("\u2019", "'"))
cleaned = re.sub(r",\s*([}\]])", r"\1", cleaned)
if cleaned != text:
attempts.append(cleaned)
last = ""
for t in attempts:
try:
obj = json.loads(t, strict=False)
except json.JSONDecodeError as exc:
last = f"{exc.msg} at line {exc.lineno} column {exc.colno}"
continue
except ValueError:
last = "unreadable"
continue
if isinstance(obj, dict):
for k in ("n", "e", "d", "p", "q", "dp", "dq", "qi", "x", "y"):
if isinstance(obj.get(k), str):
obj[k] = re.sub(r"\s+", "", obj[k])
return obj, None
return None, last
def _load_jwk() -> dict:
"""OKTA_SYNC_PRIVATE_KEY is the private key as a JWK. Two forms are accepted:
the JSON itself (it starts with "{"), or that JSON encoded as base64. Use base64
in a Portainer environment field: it has no quote marks to be mangled.
The reader forgives the usual copy and paste damage: quote marks around the whole
value, spaces and line breaks inside it, missing "=" padding, the URL-safe base64
alphabet, a byte-order mark at the start of the file, and a JWK Set
({"keys": [one key]}) in place of a single key. Raises OktaSyncError that says
which step failed. A message never holds any text of the key, only counts."""
raw = _key_raw()
if not raw:
raise _fail("OKTA_SYNC_PRIVATE_KEY is not set")
if len(raw) >= 2 and raw[0] == raw[-1] and raw[0] in "\"'" and raw[0] not in raw[1:-1]:
raw = raw[1:-1].strip()
if raw.startswith(("{", '"', "-----BEGIN")):
text = raw
else:
compact = re.sub(r"\s+", "", raw)
compact += "=" * (-len(compact) % 4)
decoded = None
for decode in (base64.b64decode, base64.urlsafe_b64decode):
try:
decoded = decode(compact)
break
except Exception: # noqa: BLE001
continue
if decoded is None:
raise _fail(f"OKTA_SYNC_PRIVATE_KEY is not valid base64 ({len(compact)} characters after "
"removing spaces; it should be one long line of letters, digits, + / =)")
try:
text = decoded.decode("utf-8-sig")
except UnicodeDecodeError:
raise _fail("OKTA_SYNC_PRIVATE_KEY decodes from base64 but the result is not text") from None
text = text.lstrip("\ufeff").strip()
via = "" if raw.startswith(("{", '"', "-----BEGIN")) else " after decoding base64"
if text.startswith("-----BEGIN"):
raise _fail("OKTA_SYNC_PRIVATE_KEY holds a PEM key (-----BEGIN ...). A JWK is needed: "
"JSON with the fields kty, kid, n, e and d")
if text.startswith('"'):
text = "{" + text.rstrip(",") + "}" # the fields were copied without the outer braces
jwk, problem = _parse_json_forgiving(text)
if problem is not None and not text.startswith("{"):
# One more layer? A value that was encoded twice decodes to base64 text.
try:
squeezed = re.sub(r"\s+", "", text)
again = base64.b64decode(squeezed + "=" * (-len(squeezed) % 4)).decode("utf-8-sig").strip()
jwk, problem = _parse_json_forgiving(again)
except Exception: # noqa: BLE001
pass
if problem is not None:
shape = ("starts with a brace" if text.startswith("{") else
"starts with a letter or digit" if text[:1].isalnum() else "starts with a symbol")
raise _fail(f"OKTA_SYNC_PRIVATE_KEY is not JSON{via} ({len(text)} characters, {shape}; {problem})")
if isinstance(jwk, dict) and isinstance(jwk.get("keys"), list):
if len(jwk["keys"]) != 1:
raise _fail("OKTA_SYNC_PRIVATE_KEY is a key set with more than one key; paste one key")
jwk = jwk["keys"][0]
if not isinstance(jwk, dict) or jwk.get("kty") not in {"RSA", "EC"}:
raise _fail("OKTA_SYNC_PRIVATE_KEY is JSON but not an RSA or EC key")
if "d" not in jwk:
raise _fail("OKTA_SYNC_PRIVATE_KEY holds a PUBLIC key; the private key is needed to sign")
return jwk
def _client_assertion(jwk: dict, client_id: str, audience: str) -> str:
"""The signed JWT that proves we hold the key. Okta's rules: iss and sub are the
client ID, aud is the token endpoint, and the lifetime is at most 60 minutes."""
alg = jwk.get("alg") or ("RS256" if jwk["kty"] == "RSA" else "ES256")
algorithms = jwt.algorithms.get_default_algorithms()
if alg not in algorithms:
raise _fail(f"the key names an algorithm that is not supported ({alg})")
try:
key = algorithms[alg].from_jwk(json.dumps(jwk))
now = int(time.time())
return jwt.encode(
{"iss": client_id, "sub": client_id, "aud": audience, "iat": now,
"exp": now + ASSERTION_LIFETIME_SECONDS, "jti": uuid.uuid4().hex},
key, algorithm=alg, headers={"kid": jwk["kid"]} if jwk.get("kid") else None)
except OktaSyncError:
raise
except Exception as exc: # noqa: BLE001
raise _fail(f"the key could not sign ({type(exc).__name__})") from None
def _dpop_mode() -> str:
"""OKTA_SYNC_DPOP (D24): "auto" (the default), "on" or "off".
auto: ask for a plain Bearer token first. If Okta answers invalid_dpop_proof, the
Okta app requires DPoP, and the sync asks again with DPoP. Nothing to set.
on: always use DPoP.
off: never use DPoP. A DPoP-bound token is then refused with a clear message."""
v = os.getenv("OKTA_SYNC_DPOP", "").strip().lower()
if v in {"1", "true", "yes", "on"}:
return "on"
if v in {"0", "false", "no", "off"}:
return "off"
return "auto"
def _url_no_query(url: str) -> str:
p = urlparse(url)
return f"{p.scheme}://{p.netloc}{p.path}"
class _Dpop:
"""DPoP (RFC 9449): proof that the caller holds a key, sent with every request, so
a stolen access token alone is useless. One throwaway EC key (P-256) is made for each
run and is never stored or logged. Each request gets its own signed proof: the method
(htm), the URL without its query (htu), a one-time id (jti), the time (iat), the
server's latest nonce if it gave one, and for an API call a hash of the access token
(ath). The public half of the key travels in the proof header."""
def __init__(self):
self._key = ec.generate_private_key(ec.SECP256R1())
pub = json.loads(jwt.algorithms.ECAlgorithm.to_jwk(self._key.public_key()))
self._pub = {k: pub[k] for k in ("kty", "crv", "x", "y")}
self.nonce: Optional[str] = None
def proof(self, method: str, url: str, access_token: Optional[str] = None) -> str:
claims = {"jti": uuid.uuid4().hex, "htm": method.upper(), "htu": _url_no_query(url),
"iat": int(time.time())}
if self.nonce:
claims["nonce"] = self.nonce
if access_token:
claims["ath"] = base64.urlsafe_b64encode(
hashlib.sha256(access_token.encode()).digest()).rstrip(b"=").decode()
return jwt.encode(claims, self._key, algorithm="ES256",
headers={"typ": "dpop+jwt", "jwk": self._pub})
def take_nonce(self, resp: httpx.Response) -> Optional[str]:
n = resp.headers.get("DPoP-Nonce")
if n:
self.nonce = n
return n
class _Credential:
"""What is sent with each Management API call: an SSWS token, a Bearer token, or a
DPoP-bound token with a fresh proof for every request."""
def __init__(self, scheme: str, token: str, dpop: Optional[_Dpop] = None):
self.scheme, self.token, self.dpop = scheme, token, dpop
def headers(self, method: str, url: str) -> dict:
h = {"Accept": "application/json"}
if self.dpop is not None:
h["Authorization"] = f"DPoP {self.token}"
h["DPoP"] = self.dpop.proof(method, url, self.token)
else:
h["Authorization"] = f"{self.scheme} {self.token}"
return h
def _error_code(resp: httpx.Response) -> str:
"""Okta's OAuth error code (invalid_client, invalid_scope, invalid_dpop_proof, ...).
It tells an admin what to fix and holds no secret. Kept only if it is a short code."""
try:
c = resp.json().get("error", "")
if isinstance(c, str) and re.fullmatch(r"[a-z_]{1,40}", c):
return c
except Exception: # noqa: BLE001
pass
return ""
def _access_token(client: httpx.Client, base: str) -> _Credential:
"""Trade a signed assertion for an access token. Raises OktaSyncError for every
failure. Neither the key, the assertion nor the token is logged or put in a message.
Each attempt gets a new assertion, because Okta accepts an assertion id only once."""
client_id = _client_id()
if not client_id:
raise _fail("OKTA_SYNC_CLIENT_ID is not set")
endpoint = f"{base}/oauth2/v1/token"
jwk = _load_jwk()
mode = _dpop_mode()
dpop: Optional[_Dpop] = _Dpop() if mode == "on" else None
nonce_retries = 0
resp = None
for _ in range(4):
headers = {"Accept": "application/json"}
if dpop is not None:
headers["DPoP"] = dpop.proof("POST", endpoint)
try:
resp = client.post(
endpoint, headers=headers, follow_redirects=False,
data={"grant_type": "client_credentials", "scope": OAUTH_SCOPE,
"client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer",
"client_assertion": _client_assertion(jwk, client_id, endpoint)})
except httpx.HTTPError as exc:
raise _fail(f"network error on the token request ({type(exc).__name__})") from None
if dpop is not None:
dpop.take_nonce(resp)
if resp.status_code == 200:
break
code = _error_code(resp)
if mode == "auto" and dpop is None and code == "invalid_dpop_proof":
dpop = _Dpop() # the Okta app requires DPoP: ask again with it
continue
if dpop is not None and code == "use_dpop_nonce" and dpop.nonce and nonce_retries < 2:
nonce_retries += 1 # Okta asks for its nonce in the proof: ask again with it
continue
raise _fail(f"Okta answered HTTP {resp.status_code} to the token request"
+ (f", error {code}" if code else "")
+ (" (DPoP was used)" if dpop is not None else ""))
else:
raise _fail("the token request did not succeed after retries")
try:
body = resp.json()
except ValueError:
raise _fail("the token response is not JSON") from None
tok = body.get("access_token") if isinstance(body, dict) else None
if not isinstance(tok, str) or not tok:
raise _fail("the token response has no access token")
kind = str(body.get("token_type", "")).lower()
if kind == "dpop":
if dpop is None:
raise _fail("the token is DPoP-bound but OKTA_SYNC_DPOP is off")
return _Credential("DPoP", tok, dpop)
if kind == "bearer":
return _Credential("Bearer", tok)
raise _fail("the token response is neither a Bearer nor a DPoP token")
def is_configured() -> bool:
return bool(auth_method() and org_url().startswith("https://"))
def describe() -> str:
"""One line for the startup log. Never contains the token."""
method = auth_method()
if not method:
return ("Okta sync DISABLED - set OKTA_API_TOKEN, or OKTA_SYNC_CLIENT_ID and "
"OKTA_SYNC_PRIVATE_KEY. Deprovisioning is not detected.")
base = org_url()
if not base:
return "Okta sync DISABLED - no OKTA_ORG_URL and OKTA_ISSUER has no host. Deprovisioning is not detected."
if not base.startswith("https://"):
return f"Okta sync DISABLED - org URL {base!r} is not https. The token is never sent over http."
mode = "DRY RUN, no account is changed" if dry_run() else "live"
how = ("API token" if method == "token"
else f"OAuth service app (private_key_jwt), DPoP {_dpop_mode()}")
return (f"Okta sync configured ({mode}) - org {base}, credential: {how}, "
f"identity claim {okta_auth.IDENTITY_CLAIM!r}")
def dry_run() -> bool:
"""OKTA_SYNC_DRY_RUN (D22). When it is 1, true, yes or on, the sync does its whole
job except the change: it logs who it WOULD disable and writes nothing. Off by
default, so a deploy that does not set it behaves as before. Read at each run,
so the value in force is the one the worker started with."""
return os.getenv("OKTA_SYNC_DRY_RUN", "").strip().lower() in {"1", "true", "yes", "on"}
def _profile_attribute() -> str:
override = os.getenv("OKTA_SYNC_PROFILE_ATTRIBUTE", "").strip()
if override:
return override
claim = okta_auth.IDENTITY_CLAIM
return _CLAIM_TO_PROFILE.get(claim, claim)
# ── the client ────────────────────────────────────────────────────────────────
def _fail(reason: str) -> "OktaSyncError":
# One place to build the error, so no call site can add a URL or a header by
# accident.
return OktaSyncError(f"Okta user list could not be fetched: {reason}")
def _same_origin(url: str, base: str) -> bool:
a, b = urlparse(url), urlparse(base)
return (a.scheme, a.netloc) == (b.scheme, b.netloc)
def _parse_user(item, attribute: str) -> OktaUser:
if not isinstance(item, dict):
raise _fail("a list item is not an object")
status = item.get("status")
profile = item.get("profile")
if not isinstance(status, str) or not status.strip():
raise _fail("a user has no status")
if not isinstance(profile, dict):
raise _fail("a user has no profile")
value = profile.get(attribute)
if not isinstance(value, str) or not value.strip():
raise _fail(f"a user has no value for profile attribute {attribute!r}")
return OktaUser(identity=value.strip(), status=status.strip().upper())
def _get_page(client: httpx.Client, cred: _Credential, url: str, params: Optional[dict]) -> httpx.Response:
"""One GET, with the credential's headers. With DPoP, each call has its own proof,
and if the server answers use_dpop_nonce the call is repeated once with its nonce."""
for attempt in (0, 1):
resp = client.get(url, params=params, headers=cred.headers("GET", url), follow_redirects=False)
if cred.dpop is None:
return resp
nonce = cred.dpop.take_nonce(resp)
asks = resp.status_code in (400, 401) and nonce and (
"use_dpop_nonce" in resp.headers.get("WWW-Authenticate", "") or "use_dpop_nonce" in resp.text)
if attempt == 0 and asks:
continue
return resp
return resp
def fetch_users(http: Optional[httpx.Client] = None) -> "list[OktaUser]":
"""Return every user Okta lists, as OktaUser values. Raises OktaSyncError on
any problem; never returns an empty list. `http` is for tests (a client built
on httpx.MockTransport). In production it is None and a short-lived client is
made here."""
method = auth_method()
base = org_url()
if not method:
raise _fail("no Okta credential is set (OKTA_API_TOKEN, or OKTA_SYNC_CLIENT_ID and OKTA_SYNC_PRIVATE_KEY)")
if not base.startswith("https://"):
raise _fail("the org URL is missing or is not https")
attribute = _profile_attribute()
own_client = http is None
client = http if http is not None else httpx.Client(timeout=TIMEOUT_SECONDS)
users: "list[OktaUser]" = []
started = time.monotonic()
try:
cred = (_Credential("SSWS", _token()) if method == "token"
else _access_token(client, base))
url: Optional[str] = f"{base}/api/v1/users"
params: Optional[dict] = {"limit": PAGE_LIMIT}
for _ in range(MAX_PAGES):
if not url:
break
if time.monotonic() - started > TOTAL_DEADLINE_SECONDS:
raise _fail(f"took longer than {int(TOTAL_DEADLINE_SECONDS)} seconds in total")
try:
resp = _get_page(client, cred, url, params)
except httpx.HTTPError as exc:
# Class name only. The exception text can carry the URL.
raise _fail(f"network error ({type(exc).__name__})") from None
if resp.status_code != 200:
raise _fail(f"Okta answered HTTP {resp.status_code}")
try:
body = resp.json()
except ValueError:
raise _fail("the response is not JSON") from None
if not isinstance(body, list):
raise _fail("the response is not a list of users")
users.extend(_parse_user(item, attribute) for item in body)
nxt = resp.links.get("next", {}).get("url")
if not nxt:
url = None
break
if not _same_origin(nxt, base):
# Never send the token to a host that the Link header names.
raise _fail("a next-page link points to a different host")
url, params = nxt, None # the next link already carries its query
else:
# The loop used every page and the last one still named a next page.
raise _fail(f"more than {MAX_PAGES} pages; the list may be cut off")
finally:
if own_client:
client.close()
if not users:
raise _fail("Okta returned no users, which is not credible for a real org")
log.info("Okta user list fetched: %d user(s)%s", len(users),
" (with DPoP)" if cred.dpop is not None else "")
return users
# ── T13.3: the sync job ───────────────────────────────────────────────────────
# Which Okta statuses mean "this person is gone or was blocked on purpose".
# Decided by Matt, 2026-10-16: a literal "anything that is not ACTIVE" would also
# catch PASSWORD_EXPIRED, LOCKED_OUT and RECOVERY, which people leave on their
# own, and because this job never re-enables, one AD password expiry would lock a
# person out of this app until an admin stepped in. A user who is MISSING from the
# list disables too (Okta's default list leaves out DEPROVISIONED users).
DISABLING_STATUSES = frozenset({"SUSPENDED", "DEPROVISIONED"})
SYNC_ACTOR = "system:okta_sync"
SYNC_ACTION = "user_deprovisioned_by_sync"
@dataclass
class SyncResult:
ok: bool # False = the run took NO action at all
error: str = "" # why, when ok is False
okta_users: int = 0 # size of the Okta list
checked: int = 0 # active local accounts looked at
disabled: "list[str]" = field(default_factory=list) # usernames disabled this run
# (in a dry run: the ones it WOULD disable)
dry_run: bool = False # True = nothing was changed on purpose (D22)
def _gen_id(prefix: str) -> str:
# Same shape as server/app.py gen_id. Not imported: app.py will import this
# module (T13.4), and the reverse import would be circular.
return f"{prefix}_{uuid.uuid4().hex[:12]}"
def run_sync(db: Session, fetch: Optional[Callable[[], "list[OktaUser]"]] = None,
dry: Optional[bool] = None) -> SyncResult:
"""Compare the Okta user list to local accounts and disable the ones Okta no
longer vouches for.
The rules, none of which may be relaxed (D18):
1. FAIL CLOSED. If fetching raises ANY exception, or the answer cannot be
trusted, this function changes nothing and writes nothing. A failure is
never read as "nobody is active". The fetch happens before the database
is read, so there is no code path from a failed fetch to a change.
2. ONLY DISABLE. It sets is_active to False. No input makes it set True.
An account that is already disabled is not touched and gets no new
audit row, so a run that finds nothing new writes nothing.
3. One AuditLog row per disabled account, actor "system:okta_sync", so it
is never confused with an admin's action. Rows and changes are saved in
one transaction. If saving fails, none of it is kept.
4. Only changes are logged. A person who is still active in Okta and still
active here produces no row.
One guard beyond the rules above, inside decision 4's "anything the sync can't
confidently parse": if there are active local accounts and NONE of them
matches any Okta user, the identity attribute is almost certainly wrong (see
OKTA_SYNC_PROFILE_ATTRIBUTE). That is a setup mistake, not an offboarding of
the whole company, so the run is refused and nothing changes.
A local account matches an Okta user by username or by email, ignoring case,
the same two fields auth.find_user() uses. If the Okta list holds the same
identity twice with different statuses, the account is disabled only when
every one of them is a disabling status.
DRY RUN (D22, OKTA_SYNC_DRY_RUN): every step above runs, including the fetch and
both guards, but the account changes and the audit rows are skipped. The run logs
who it would disable. Use it for the first deploy, to see the match count and the
list before any account is touched.
`fetch` and `dry` are for tests. In production fetch is None and fetch_users() is
used, and dry is None so the environment decides.
"""
fetch = fetch or fetch_users
dry = dry_run() if dry is None else dry
# 1. The fetch. Nothing below runs unless it returned a list.
try:
okta_users = fetch()
except Exception as exc: # an error of ANY kind, not only OktaSyncError
msg = str(exc) if isinstance(exc, OktaSyncError) else f"unexpected {type(exc).__name__}"
log.error("Okta sync SKIPPED, no account was changed: %s", msg)
return SyncResult(ok=False, error=msg)
if not okta_users:
# fetch_users() already raises on an empty list. This covers a stand-in
# fetch (and any future change) that returns one: same rule.
msg = "the fetch returned no users"
log.error("Okta sync SKIPPED, no account was changed: %s", msg)
return SyncResult(ok=False, error=msg)
try:
by_identity: "dict[str, list[str]]" = {}
for u in okta_users:
by_identity.setdefault(u.identity.strip().lower(), []).append(u.status.strip().upper())
locals_ = list(db.scalars(select(models.User).where(models.User.is_active.is_(True))))
plan: "list[tuple[models.User, str]]" = []
matched = 0
for local in locals_:
statuses: "list[str]" = []
for key in {(local.username or "").strip().lower(), (local.email or "").strip().lower()}:
if key:
statuses.extend(by_identity.get(key, []))
if statuses:
matched += 1
if all(st in DISABLING_STATUSES for st in statuses):
plan.append((local, sorted(set(statuses))[0]))
else:
plan.append((local, "MISSING"))
if locals_ and matched == 0:
msg = (f"none of {len(locals_)} active local account(s) matches any of "
f"{len(okta_users)} Okta user(s); the identity attribute is probably wrong")
log.error("Okta sync SKIPPED, no account was changed: %s", msg)
return SyncResult(ok=False, error=msg, okta_users=len(okta_users), checked=len(locals_))
planned = [(local.username, status) for local, status in plan]
checked = len(locals_)
if not dry:
for local, status in plan:
local.is_active = False
db.add(models.AuditLog(
id=_gen_id("ev"), actor=SYNC_ACTOR, action=SYNC_ACTION,
entity_type="user", entity_id=local.id, project_id=None,
summary=local.username[:400],
detail={"okta_status": status, "via": "okta_sync"},
))
db.commit()
except Exception as exc:
db.rollback()
log.error("Okta sync FAILED, nothing was kept: unexpected %s", type(exc).__name__)
return SyncResult(ok=False, error=f"unexpected {type(exc).__name__}")
if dry:
for name, status in planned:
log.warning("Okta sync DRY RUN would disable %r (Okta status: %s)", name, status)
log.info("Okta sync DRY RUN done, no account was changed: %d Okta user(s), %d active "
"local account(s) checked, %d matched, %d would be disabled",
len(okta_users), checked, matched, len(planned))
return SyncResult(ok=True, okta_users=len(okta_users), checked=checked,
disabled=[name for name, _ in planned], dry_run=True)
for name, status in planned:
log.warning("Okta sync disabled %r (Okta status: %s)", name, status)
log.info("Okta sync done: %d Okta user(s), %d active local account(s) checked, %d disabled",
len(okta_users), checked, len(planned))
return SyncResult(ok=True, okta_users=len(okta_users), checked=checked,
disabled=[name for name, _ in planned])
# ── T13.4: running it on a schedule ───────────────────────────────────────────
# The api container runs gunicorn with 2 workers, and a later deploy may run more
# than one container. Each worker starts its own timer thread below. Without a
# gate, all of them would call Okta every cycle and write overlapping changes.
# The gate is one row in app_settings (key "okta_sync"). Its updated_at is "when
# the last run was claimed". A worker claims a run with ONE atomic conditional
# UPDATE: it succeeds only if the last claim is older than the interval. Exactly
# one worker wins each cycle, on SQLite and on Postgres, with no lock held.
#
# The row survives a restart, so a restart inside the interval does not start a
# second run. A slow run cannot overlap the next: a fetch is bounded to
# TOTAL_DEADLINE_SECONDS (120) and the interval can never be set below
# INTERVAL_MIN_SECONDS (300). Inside one process the timer thread runs one cycle at
# a time, so cycles cannot stack there either.
CLAIM_KEY = "okta_sync"
INTERVAL_DEFAULT_SECONDS = 900 # 15 minutes (D18, proposed, not confirmed)
INTERVAL_MIN_SECONDS = 300
TICK_SECONDS = 60 # how often each worker checks if a run is due
START_DELAY_SECONDS = 10 # let the app finish starting first
def interval_seconds() -> int:
"""OKTA_SYNC_INTERVAL_SECONDS, default 900. A value that is not a number uses
the default. A value under 300 is raised to 300 (see above for why)."""
raw = os.getenv("OKTA_SYNC_INTERVAL_SECONDS", "").strip()
if not raw:
return INTERVAL_DEFAULT_SECONDS
try:
value = int(raw)
except ValueError:
log.warning("OKTA_SYNC_INTERVAL_SECONDS=%r is not a whole number; using %d",
raw, INTERVAL_DEFAULT_SECONDS)
return INTERVAL_DEFAULT_SECONDS
if value < INTERVAL_MIN_SECONDS:
log.warning("OKTA_SYNC_INTERVAL_SECONDS=%d is under the minimum; using %d",
value, INTERVAL_MIN_SECONDS)
return INTERVAL_MIN_SECONDS
return value
def claim(db: Session, interval: int, now: Optional[datetime] = None) -> bool:
"""Try to claim this cycle. True for exactly one caller per interval."""
now = now or datetime.now(timezone.utc)
cutoff = now - timedelta(seconds=interval)
try:
row = db.get(models.AppSetting, CLAIM_KEY)
if row is None:
db.add(models.AppSetting(key=CLAIM_KEY, value={}, updated_at=now))
db.commit() # the insert is the claim
return True
except IntegrityError:
db.rollback() # another worker inserted first: it won
return False
db.rollback() # end the read; the UPDATE starts fresh
result = db.execute(
update(models.AppSetting)
.where(models.AppSetting.key == CLAIM_KEY, models.AppSetting.updated_at <= cutoff)
.values(updated_at=now)
)
db.commit()
return result.rowcount == 1
def run_if_due(session_factory: Callable[[], Session],
fetch: Optional[Callable[[], "list[OktaUser]"]] = None,
now: Optional[datetime] = None) -> Optional[SyncResult]:
"""One timer tick: claim the cycle, and if it is ours, run the sync. Returns
the SyncResult, or None when the cycle was not ours (or could not be claimed).
Nothing here can turn a failure into a change: run_sync() owns that rule, and
anything that goes wrong around it is logged and ends the tick."""
try:
with session_factory() as db:
if not claim(db, interval_seconds(), now=now):
return None
with session_factory() as db:
return run_sync(db, fetch=fetch)
except Exception as exc:
log.error("Okta sync tick failed, no account was changed: unexpected %s", type(exc).__name__)
return None
def start_scheduler(session_factory: Callable[[], Session]) -> "Optional[threading.Event]":
"""Start the timer thread. Returns a stop Event (set it to end the thread), or
None when the sync is off because OKTA_API_TOKEN or the org URL is missing.
Logs one line either way, so an operator can see it in `docker compose logs api`."""
log.info(describe())
if not is_configured():
return None
stop = threading.Event()
def loop():
if stop.wait(START_DELAY_SECONDS):
return
while not stop.is_set():
run_if_due(session_factory)
if stop.wait(TICK_SECONDS):
return
threading.Thread(target=loop, name="okta-sync", daemon=True).start()
log.info("Okta sync scheduled: every %d seconds (checked each %d s by every worker; "
"one wins each cycle)", interval_seconds(), TICK_SECONDS)
return stop

View File

@@ -17,6 +17,11 @@ pymssql==2.3.13 # read-only lookups against the Micron asset DB (SQL
# MICRON_DB_URL to mssql+pyodbc://…?driver=ODBC+Driver+18+for+SQL+Server
pydantic==2.13.4
python-dotenv==1.2.2
bcrypt==5.0.0 # password hashing
PyJWT==2.13.0 # signed session tokens
PyJWT==2.15.1 # signed session tokens. D21 (2026-10-02): was 2.13.0, which
# pip-audit lists 13 advisories for (GHSA-8wjv-2p76-3863 let a
# crafted cookie raise past decode_token). 2.15.1: none known.
starlette==1.3.1 # pinned transitive (cookie / CORS handling — security-relevant)
Authlib==1.7.2 # Okta OIDC authorization-code flow (T10.1, wave 10 / D15)
httpx==0.28.1 # Authlib's OIDC client needs an HTTP client; explicit, not transitive
itsdangerous==2.2.0 # signs the OAuth-state cookie SessionMiddleware sets — required by
# Authlib's authorize_redirect/authorize_access_token, not optional

View File

@@ -9,15 +9,17 @@ and to have data to inspect.
Every /api/ route except /api/health requires a session, so this signs in first and
keeps the session cookie for the rest of the run — the same way server/smoketest.py
does, reusing its opener rather than growing a second implementation of it.
Credentials come from the environment so the password never has to appear in a
command line or shell history:
does, reusing its opener AND its session-minting (not a second implementation).
There is no local password anymore (D15/D16, T10.4) — see smoketest.py's own
AUTHENTICATION section for why and what that means: this needs to run where it can
read the SAME AUTH_SECRET_KEY and reach the SAME database as the server under test,
and the account must already exist (this seeds a project, not a user).
export WP_SEED_USER=<admin-account> # or WP_SMOKE_USER, which is reused
export WP_SEED_PASSWORD='…' # or WP_SMOKE_PASSWORD
…or pass --user / --password. Use an admin account: seeding creates a project, and
--clean deletes one, which needs Project Admin on it.
…or pass --user. Use an admin account: seeding creates a project, and --clean
deletes one, which needs Project Admin on it.
USAGE
python3 server/seed_demo.py https://wp-suite.company.local --insecure
@@ -48,16 +50,19 @@ import urllib.error
import urllib.request
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
# So `from server import auth, models` / `from server.db import SessionLocal` also
# resolve (needed to mint a session — see AUTHENTICATION above).
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
# The session handling is smoketest.py's, imported rather than copied: one cookie
# jar implementation, one login flow, one place to fix. Importing is safe — that
# module does its work under `if __name__ == "__main__"`.
from smoketest import build_opener # noqa: E402
# jar implementation, one session-minting flow, one place to fix. Importing is
# safe — that module does its work under `if __name__ == "__main__"`.
from smoketest import build_opener, seed_session_cookie # noqa: E402
BASE = ""
CTX = None
# Carries the cookie jar holding the session issued by /api/auth/login. This
# script used to call urllib.request.urlopen() directly, which has no cookie
# Carries the cookie jar holding the minted session (see AUTHENTICATION above).
# This script used to call urllib.request.urlopen() directly, which has no cookie
# support, so the session was dropped and every data route answered 401 (S13).
OPENER = None
DEMO_NUMBER = "DEMO-001" # project number prefix used to find/clean demo data
@@ -116,29 +121,22 @@ def main():
ap.add_argument("--insecure", action="store_true", help="skip TLS verification")
ap.add_argument("--clean", action="store_true", help="delete existing DEMO-* projects and exit")
ap.add_argument("--user", default=os.getenv("WP_SEED_USER", "") or os.getenv("WP_SMOKE_USER", ""),
help="account to sign in as (default: $WP_SEED_USER, then $WP_SMOKE_USER). "
"Use an admin account.")
ap.add_argument("--password",
default=os.getenv("WP_SEED_PASSWORD", "") or os.getenv("WP_SMOKE_PASSWORD", ""),
help="its password (default: $WP_SEED_PASSWORD, then $WP_SMOKE_PASSWORD — "
"preferred, so it stays out of shell history)")
help="existing account to sign in as (default: $WP_SEED_USER, then "
"$WP_SMOKE_USER). Use an admin account.")
args = ap.parse_args()
BASE = args.base_url.rstrip("/")
if args.insecure:
CTX = ssl.create_default_context(); CTX.check_hostname = False; CTX.verify_mode = ssl.CERT_NONE
OPENER = build_opener(CTX)
if not args.user or not args.password:
missing = " and ".join(n for n, v in (("WP_SEED_USER", args.user),
("WP_SEED_PASSWORD", args.password)) if not v)
if not args.user:
return abort(
f"no credentials — {missing} not set.",
"no account — $WP_SEED_USER not set.",
" Every /api/ route except /api/health needs a session, so there is nothing\n"
" this can seed without one. Set them and re-run:\n\n"
" export WP_SEED_USER=<admin-account>\n"
" export WP_SEED_PASSWORD='…'\n\n"
" Or pass --user/--password. WP_SMOKE_USER / WP_SMOKE_PASSWORD are accepted\n"
" too, so one set of credentials serves this and smoketest.py.")
" this can seed without one. Set it and re-run:\n\n"
" export WP_SEED_USER=<admin-account>\n\n"
" Or pass --user. WP_SMOKE_USER is accepted too, so one account name serves\n"
" this and smoketest.py.")
# health gate
try:
@@ -148,18 +146,25 @@ def main():
if st != 200:
print(f"ABORT: /api/health returned {st}"); return 1
# Sign in. The cookie the response sets is held by OPENER's jar and rides every
# request after this one.
st, body = call("POST", "/api/auth/login",
{"username": args.user, "password": args.password})
if st != 200:
detail = body.get("detail") if isinstance(body, dict) else body
hint = (" The account may be locked: the API locks an account for a while after a\n"
" few consecutive failures, so retrying with the wrong password makes this\n"
" worse. Check the password, then wait out the lockout window."
if st in (401, 403, 423, 429) else
" Unexpected status from the login endpoint — check the API logs.")
return abort(f"could not sign in as '{args.user}' (HTTP {st}): {detail}", hint)
# "Sign in" — mint a session directly (see AUTHENTICATION above) and seed it
# into OPENER's jar, so it rides every request after this one.
try:
from server import auth as srv_auth
from server.db import SessionLocal
except ImportError as e:
return abort(f"cannot import the server package to mint a session: {e}",
" This needs to run where server/ is importable and AUTH_SECRET_KEY /\n"
" DATABASE_URL match the target server's — see AUTHENTICATION above.")
with SessionLocal() as db:
user = srv_auth.find_user(db, args.user)
if not user:
return abort(f"no account named '{args.user}'.",
" This signs in as an existing account, it doesn't create one — sign in\n"
" through Okta once first, or create it from the admin console.")
if not user.is_active:
return abort(f"'{args.user}' is disabled.", "")
token = srv_auth.create_token(user)
seed_session_cookie(token, BASE)
logged_in = True
print(f"Signed in as {args.user}.")

View File

@@ -6,16 +6,23 @@ NGINX → FastAPI → PostgreSQL all work and that the Python logic (the AWP
release gate, metrics, cascade delete) behaves. Stdlib only — no pip, no jq.
AUTHENTICATION
Every /api/ route except /api/health requires a session (auth_gate in
server/app.py), so the script signs in first and keeps the session cookie for
the rest of the run. Credentials come from the environment by preference, so a
password never has to appear in a command line or shell history:
There is no local password anymore (D15/D16, T10.4) — identity is Okta's job,
and Okta requires a real browser to complete, which this stdlib script cannot
do. So instead of signing in over HTTP the way the front end does, this script
mints a session the same way server/app.py's okta_callback() does after Okta
hands back an identity: auth.create_token() for an existing account, seeded
straight into the cookie jar. That means it needs to run somewhere that can
read the SAME AUTH_SECRET_KEY and reach the SAME database as the server under
test — inside the api container, or locally against your dev DB. It can no
longer sign in to an arbitrary remote URL from an unrelated workstation; if
the target is remote, run it on that host or inside that container instead.
export WP_SMOKE_USER=smoketest
export WP_SMOKE_PASSWORD='…'
python3 server/smoketest.py https://wp-suite.company.local
…or pass --user / --password explicitly.
…or pass --user explicitly. The account must already exist — sign it in
through Okta once first (or create it from the admin console) if it doesn't;
this script promotes no one and provisions nothing.
Use an ADMIN account. The script creates a project and deletes it again at the
end, and deleting one takes Project Admin on that project (require_project_admin);
@@ -24,26 +31,29 @@ AUTHENTICATION
discover it in the cleanup step.
USAGE
# Against the deployed site (through the NGINX proxy):
python3 server/smoketest.py https://wp-suite.company.local
# Self-signed / internal TLS cert? skip verification:
python3 server/smoketest.py https://wp-suite.company.local --insecure
# From inside the api container (hits FastAPI directly):
docker compose exec -e WP_SMOKE_USER -e WP_SMOKE_PASSWORD api \
# From inside the api container (has AUTH_SECRET_KEY and DATABASE_URL; hits
# FastAPI directly):
docker compose exec -e WP_SMOKE_USER api \
python /app/server/smoketest.py http://localhost:8000
# Local dev, against the app you're running yourself:
export AUTH_SECRET_KEY=... DATABASE_URL=... WP_SMOKE_USER=smoketest
python3 server/smoketest.py http://localhost:8000
# Self-signed / internal TLS cert on the HTTP side? skip verification:
python3 server/smoketest.py https://wp-suite.company.local --insecure
# Leave the demo project in the database so you can open it in the UI:
python3 server/smoketest.py https://wp-suite.company.local --keep
python3 server/smoketest.py http://localhost:8000 --keep
The base URL is the SITE root (no /api). Default: http://localhost:8000
Exit codes: 0 = all checks passed · 1 = one or more checks failed · 2 = the run
could not start (unreachable host, missing or rejected credentials). 2 is kept
distinct on purpose: "I could not test this" is not the same answer as "this is
broken", and conflating them is what made an unauthenticated version of this
script report a wall of failures against a perfectly healthy stack.
could not start (unreachable host, missing credentials, or no account by that
username). 2 is kept distinct on purpose: "I could not test this" is not the
same answer as "this is broken", and conflating them is what made an
unauthenticated version of this script report a wall of failures against a
perfectly healthy stack.
"""
import argparse
import http.cookiejar
@@ -53,6 +63,12 @@ import ssl
import sys
import urllib.error
import urllib.request
from urllib.parse import urlparse
# So `from server import auth, models` / `from server.db import SessionLocal` resolve
# when this file is run directly (`python3 server/smoketest.py`) rather than as
# `python -m server.smoketest` — same reasoning as the sys.path lines in tests/*.py.
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
# ── tiny colored reporter ─────────────────────────────────────────────────────
_PASS, _FAIL = [], []
@@ -66,19 +82,40 @@ def check(name, cond, detail=""):
BASE = ""
CTX = None
# One opener for the whole run, carrying the cookie jar that holds the session
# issued by /api/auth/login. urlopen() has no cookie support, which is why the
# session used to be dropped on the floor and every data route answered 401.
# One opener for the whole run, carrying the cookie jar that holds the session.
# urlopen() has no cookie support, which is why the session used to be dropped on
# the floor and every data route answered 401.
OPENER = None
COOKIE_JAR = None
def build_opener(ctx=None):
handlers = [urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar())]
global COOKIE_JAR
COOKIE_JAR = http.cookiejar.CookieJar()
handlers = [urllib.request.HTTPCookieProcessor(COOKIE_JAR)]
if ctx is not None:
handlers.append(urllib.request.HTTPSHandler(context=ctx))
return urllib.request.build_opener(*handlers)
def seed_session_cookie(token: str, base: str) -> None:
"""Put a minted session into the jar directly, the same shape a Set-Cookie
response from the old /api/auth/login would have produced — so the logout
check below (which relies on the jar honoring logout()'s Set-Cookie that
expires it) keeps working unchanged. `base` is explicit rather than read off
this module's own BASE global, so seed_demo.py (which imports this function
but has its own BASE) seeds the cookie for the host it's actually targeting."""
host = urlparse(base).hostname or "localhost"
COOKIE_JAR.set_cookie(http.cookiejar.Cookie(
version=0, name="wp_session", value=token,
port=None, port_specified=False,
domain=host, domain_specified=True, domain_initial_dot=False,
path="/", path_specified=True,
secure=False, expires=None, discard=True,
comment=None, comment_url=None, rest={"HttpOnly": None},
))
def call(method, path, body=None):
"""Returns (status_code, parsed_body). Never raises on HTTP status."""
url = BASE + path
@@ -116,10 +153,7 @@ def main():
ap.add_argument("--insecure", action="store_true", help="skip TLS verification")
ap.add_argument("--keep", action="store_true", help="keep the demo project (don't delete)")
ap.add_argument("--user", default=os.getenv("WP_SMOKE_USER", ""),
help="account to sign in as (default: $WP_SMOKE_USER). Use an admin account.")
ap.add_argument("--password", default=os.getenv("WP_SMOKE_PASSWORD", ""),
help="its password (default: $WP_SMOKE_PASSWORD — preferred, "
"so it stays out of shell history)")
help="existing account to sign in as (default: $WP_SMOKE_USER). Use an admin account.")
args = ap.parse_args()
BASE = args.base_url.rstrip("/")
if args.insecure:
@@ -128,17 +162,14 @@ def main():
print(f"\nWork Package Suite — API smoke test\nTarget: {BASE}\n")
# Refuse to start without credentials rather than running headlong into 401s.
if not args.user or not args.password:
missing = " and ".join(
n for n, v in (("WP_SMOKE_USER", args.user), ("WP_SMOKE_PASSWORD", args.password)) if not v)
# Refuse to start without a username rather than running headlong into 401s.
if not args.user:
return abort(
f"no credentials — {missing} not set.",
"no account — $WP_SMOKE_USER not set.",
" Every /api/ route except /api/health needs a session, so there is nothing\n"
" meaningful to test without one. Set them and re-run:\n\n"
" export WP_SMOKE_USER=<admin-account>\n"
" export WP_SMOKE_PASSWORD='…'\n\n"
" Or pass --user/--password. Use an admin account: the run creates a project\n"
" meaningful to test without one. Set it and re-run:\n\n"
" export WP_SMOKE_USER=<admin-account>\n\n"
" Or pass --user. Use an admin account: the run creates a project\n"
" and deletes it again, and the delete needs Project Admin on it.")
project_id = None
@@ -157,21 +188,29 @@ def main():
check("health endpoint returns ok", st == 200 and isinstance(body, dict) and body.get("ok") is True,
f"status={st} body={body}")
# 2) Sign in. The cookie the response sets is held by OPENER's jar and rides
# every request after this one.
st, body = call("POST", "/api/auth/login",
{"username": args.user, "password": args.password})
if st != 200:
detail = body.get("detail") if isinstance(body, dict) else body
hint = (" The account may be locked: the API locks an account for a while after\n"
" a few consecutive failures (AUTH_MAX_ATTEMPTS / AUTH_LOCKOUT_MINUTES),\n"
" so re-running with the wrong password makes this worse, not better.\n"
" Check the password, then wait out the lockout window."
if st in (401, 403, 423, 429) else
" Unexpected status from the login endpoint — check the API logs.")
return abort(f"could not sign in as '{args.user}' (HTTP {st}): {detail}", hint)
# 2) "Sign in" — mint a session directly (see AUTHENTICATION above) and seed
# it into OPENER's jar, so it rides every request after this one exactly the
# way a real Set-Cookie response would have.
try:
from server import auth as srv_auth
from server.db import SessionLocal
except ImportError as e:
return abort(f"cannot import the server package to mint a session: {e}",
" This script now needs to run where server/ is importable and\n"
" AUTH_SECRET_KEY / DATABASE_URL match the target server's — see\n"
" AUTHENTICATION above.")
with SessionLocal() as db:
user = srv_auth.find_user(db, args.user)
if not user:
return abort(f"no account named '{args.user}'.",
" This script signs in as an existing account, it doesn't create one —\n"
" sign in through Okta once first, or create it from the admin console.")
if not user.is_active:
return abort(f"'{args.user}' is disabled.", "")
token = srv_auth.create_token(user)
seed_session_cookie(token, BASE)
logged_in = True
check("login issues a session", st == 200)
check("session cookie seeded", bool(token))
# 3) Prove the session actually travels — this is the check whose absence let
# an unauthenticated version of this script look like a broken stack.

View File

@@ -241,40 +241,34 @@ def main():
# Only what the badge RENDERS counts. The phrase still appears in the
# comment explaining why it was changed, and asserting on that would be
# asserting that the reason cannot be written down.
rendered = [ln for ln in src.split("\n")
if ("el.textContent" in ln or "el.innerHTML" in ln)
and "All changes saved" in ln]
# T14.3: the badge's words now live in one place, badgeModel(), as
# `text: '...'` entries. Those are the lines that render.
texts = [ln for ln in src.split("\n") if "text: '" in ln and "tone: '" in ln]
rendered = [ln for ln in texts if "All changes saved" in ln]
chk("the badge no longer renders 'All changes saved'", not rendered, rendered[:1])
chk("the badge words were found (a rename must not make this check empty)", len(texts) >= 7,
"found %d" % len(texts))
chk("...and every state it renders names the project",
all("the project" in ln
for ln in src.split("\n")
if ("el.textContent = '" in ln or "el.innerHTML = '" in ln)
and "wp-sync-badge" not in ln and ("✓" in ln or "⚠" in ln or "↻" in ln or "✕" in ln)),
[ln.strip()[:70] for ln in src.split("\n")
if ("el.textContent = '" in ln or "el.innerHTML = '" in ln)
and "the project" not in ln and ("✓" in ln or "⚠" in ln or "↻" in ln or "✕" in ln)])
all("the project" in ln for ln in texts),
[ln.strip()[:70] for ln in texts if "the project" not in ln])
print("\n7. the analytics dwell listener still fires")
print("\n7. autosave's own registration survives the retired analytics tracker")
# This section used to also assert the per-browser usage-analytics dwell
# listener (wp-usage.js) still fired alongside autosave, to catch autosave
# accidentally replacing it. CR-019/T11.6 (2026-09-23) retired that tracker
# on purpose - track() is now a documented no-op and wp-usage.js is gone -
# so asserting it still records an event would be asserting the wrong
# thing. What's still worth checking here is autosave's own registration,
# which is what this section actually guards.
boot(page, base, tok, "/work-package-suite.html?project=projA&tab=sop")
time.sleep(0.8)
chk("the wizard still has its analytics dwell tracker",
page.eval("typeof trackStepDwell === 'function'"))
chk("...and the wizard registered autosave too",
chk("the wizard registered autosave",
page.eval("typeof WPAutosave === 'object' && typeof sopDraftId === 'function'"))
before = page.eval("""(() => {
try { return (JSON.parse(localStorage.getItem('wp_suite_analytics_v1')||'{}').events||[]).length; }
catch(e){ return -1; }
})()""")
# trackStepDwell only records a dwell longer than 400ms, so give it one.
time.sleep(0.9)
page.eval("typeof trackStepDwell==='function' && trackStepDwell()")
time.sleep(0.4)
after_n = page.eval("""(() => {
try { return (JSON.parse(localStorage.getItem('wp_suite_analytics_v1')||'{}').events||[]).length; }
catch(e){ return -1; }
})()""")
chk("calling it records an event (it was not replaced by the guard)",
after_n > before, "%s -> %s" % (before, after_n))
chk("...and the retired dwell tracker is a harmless no-op, not missing or throwing",
page.eval("""(() => {
if (typeof trackStepDwell !== 'function') return false;
try { trackStepDwell(); return true; } catch (e) { return false; }
})()"""))
finally:
page.close()
browser.close()

View File

@@ -26,6 +26,7 @@ browser found, or the server would not start). 2 is distinct on purpose: "I coul
not test this" is not the same answer as "this is broken".
"""
import argparse
import json
import os
import subprocess
import sys
@@ -39,7 +40,6 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import cdp # noqa: E402
PW = "CorrectHorseBattery9"
_PASS, _FAIL = [], []
@@ -86,7 +86,7 @@ def seed(db_path):
def mk(username, role):
db.add(models.User(id="user_" + username, username=username,
email=f"{username}@example.test", full_name=username.title(),
password_hash=auth.hash_password(PW), role=role))
role=role))
mk("root", auth.ROLE_ADMIN)
mk("sue", auth.ROLE_PROJECT_SUPER) # super user on Job A
@@ -150,10 +150,29 @@ def seed(db_path):
for u in db.query(models.User).all()}
def start_server(port, db_path):
# T10.7. The app authenticates through Okta, which no test can reach, and
# start_server launches it as a SUBPROCESS — so a monkeypatch here would never
# reach the code doing the authenticating. server/okta_fake.py reads this
# instead, and refuses to work against a non-SQLite database.
#
# Almost no check ever signs in (seed() mints tokens with auth.create_token and
# sets the cookie directly), so this matters only where the sign-in ROUND TRIP
# is driven — url_state_check's deep-link case. It is set for every server here
# anyway so that a test which starts signing in later does not fail
# mysteriously — the same reasoning the LDAP predecessor (D13/T10.7) used.
FAKE_DIRECTORY = json.dumps({
u: {"email": f"{u}@example.test", "name": u.title()}
for u in ("root", "sue", "pat", "mix", "bob", "sam", "legacy", "new")
})
def start_server(port, db_path, extra_env=None):
env = dict(os.environ)
env["DATABASE_URL"] = "sqlite:///" + db_path.replace("\\", "/")
env.setdefault("AUTH_SECRET_KEY", "browser-check-secret-not-for-production")
env["WP_OKTA_FAKE_DIRECTORY"] = FAKE_DIRECTORY
if extra_env:
env.update(extra_env)
proc = subprocess.Popen(
[sys.executable, "-m", "uvicorn", "server.app:app", "--host", "127.0.0.1",
"--port", str(port), "--log-level", "warning"],
@@ -188,9 +207,12 @@ def run(page, base, tok):
chk("auth resolved to the admin account", page.eval("(window.WP_USER||{}).role") == "admin")
chk("the directory is visible",
page.eval("getComputedStyle(document.getElementById('users-main')).display") != "none")
chk("manager table renders 9 columns",
page.eval("document.querySelectorAll('#users-table thead th').length") == 9,
# 10 since CR-020 (T12.2): the 9 data columns plus the row-selection column.
chk("manager table renders 10 columns (9 + row selection)",
page.eval("document.querySelectorAll('#users-table thead th').length") == 10,
page.eval("document.querySelectorAll('#users-table thead th').length"))
chk("...the first is the selection column",
page.eval("!!document.querySelector('#users-table thead th.selcell #sel-all')"))
chk("an admin sees every account in the fixture (7)",
page.eval("document.querySelectorAll('#users-table tbody tr').length") == 7,
page.eval("document.querySelectorAll('#users-table tbody tr').length"))
@@ -218,15 +240,22 @@ def run(page, base, tok):
# Your own row: permissions locked so you cannot demote yourself, job function
# still editable. Asserted on the two cells, not "no select in the row".
# The cells are found by their HEADER, not by position: CR-020's selection
# column moved every column one to the right and these asserted r.cells[3]
# and [4], which then read the username and the email (T12.6).
ROW = ("const r=[...document.querySelectorAll('#users-table tbody tr')]"
".find(r=>r.querySelector('.me-tag'));")
".find(r=>r.querySelector('.me-tag'));"
"const col=n=>[...document.querySelectorAll('#users-table thead th')]"
".findIndex(h=>h.textContent.trim().toLowerCase()===n);")
def own(q):
return "(()=>{" + ROW + "if(!r)return false;const c=r.cells[3];return " + q + "})()"
return "(()=>{" + ROW + "if(!r)return false;const c=r.cells[col('permissions')];return " + q + "})()"
chk("your own permissions cell is locked, not a dropdown",
page.eval(own("!c.querySelector('select') && !!c.querySelector('.tag')")))
chk("...and wears the Administrator pill", page.eval(own("!!c.querySelector('.tag.admin')")))
chk("...while your job function stays editable",
page.eval("(()=>{" + ROW + "return !!r && !!r.cells[4].querySelector('select')})()"))
page.eval("(()=>{" + ROW + "return !!r && !!r.cells[col('project role')].querySelector('select')})()"))
chk("...and your own row cannot be ticked for a bulk action",
page.eval("(()=>{" + ROW + "return !!r && !r.querySelector('input.selbox')})()"))
page.eval("[...document.querySelectorAll('#users-table tbody button')]"
".find(b=>/project/i.test(b.textContent)).click()")
@@ -436,7 +465,10 @@ def main():
finally:
if args.keep_server:
print(f"\n --keep-server: still up at {base}, database at {db_path}")
print(" Sign in as root / " + PW)
# No local password exists (D15/D16) — there's nothing to type into a login
# form. Set the session cookie directly, the same way this script's own
# fixture does, from the browser console on that origin:
print(f" document.cookie = 'wp_session={tok['root']}; path=/'")
else:
if server:
# Wait for it to actually exit before deleting the database out from

326
tests/bulk_users_check.py Normal file
View File

@@ -0,0 +1,326 @@
#!/usr/bin/env python3
"""CR-020 (wave 12): bulk user administration, server side.
python tests/bulk_users_check.py
Self-contained and needs NO browser: a throwaway SQLite database in a temp
folder, the API driven in-process with FastAPI's TestClient, everything deleted
afterward. Your real wpsuite.db is never touched.
What it proves is the wave's own exit criteria, measured on the server, where
they are enforced:
- every bulk action works on a list, row by row, with the single-user rules;
- the caller's own account is refused on its own row, never the whole batch;
- a super user's batch cannot reach an account or project outside their scope;
- one AuditLog row per changed account, the same shape the single route writes;
- a partial failure is reported row by row, never as a clean success;
- project add/remove never touches the user's other projects or their roles;
- the single-user routes, now built on the same functions, behave as before.
Exit codes: 0 all passed, 1 a check failed, 2 the run could not start.
"""
import os
import shutil
import sys
import tempfile
import warnings
warnings.filterwarnings("ignore")
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
TMP = tempfile.mkdtemp(prefix="wp-bulk-users-check-")
os.environ["DATABASE_URL"] = "sqlite:///" + os.path.join(TMP, "bulk.db").replace("\\", "/")
os.environ["AUTH_SECRET_KEY"] = "bulk-users-check-key-bulk-users-check-0000"
os.environ.pop("WP_OKTA_FAKE_DIRECTORY", None)
sys.path.insert(0, ROOT)
try:
from fastapi.testclient import TestClient
from sqlalchemy import select
from server import app as A, auth, models
from server.db import SessionLocal
except Exception as exc: # noqa: BLE001
print("could not start:", exc)
sys.exit(2)
RESULTS = []
def check(name, ok, detail=""):
RESULTS.append(bool(ok))
print(f" {'PASS' if ok else 'FAIL'} {name}" + (f" ({detail})" if detail and not ok else ""))
db = SessionLocal()
def account(uid, role="project_user"):
u = models.User(id=uid, username=uid[5:], role=role, email=uid[5:] + "@example.test")
db.add(u)
db.commit()
return u
def member(uid, pid, role=""):
db.add(models.ProjectMember(id=f"pm_{uid}_{pid}", user_id=uid, project_id=pid, role=role))
db.commit()
def client(user):
c = TestClient(A.app, base_url="http://127.0.0.1", raise_server_exceptions=False)
c.cookies.set(auth.COOKIE_NAME, auth.create_token(user))
return c
def fresh():
s = SessionLocal()
s.expire_all()
return s
def audit(action, entity_id=None):
s = fresh()
q = select(models.AuditLog).where(models.AuditLog.action == action)
if entity_id:
q = q.where(models.AuditLog.entity_id == entity_id)
return s.scalars(q.order_by(models.AuditLog.at)).all()
def roles_of(uid):
s = fresh()
return {m.project_id: (m.role or "") for m in
s.scalars(select(models.ProjectMember).where(models.ProjectMember.user_id == uid))}
def by_user(resp):
return {r["user_id"]: r for r in resp.json().get("results", [])}
# ── fixture ──────────────────────────────────────────────────────────────────
admin = account("user_admin", "admin")
admin2 = account("user_admin2", "admin")
superu = account("user_super") # super user on proj1 and proj4 by membership
pu = account("user_pu") # plain project user: manages nobody
for n in range(1, 10):
account(f"user_u{n}")
for pid in ("proj1", "proj2", "proj3", "proj4"):
db.add(models.Project(id=pid, name=pid))
db.commit()
member("user_super", "proj1", "project_super_user")
member("user_super", "proj4", "project_super_user")
member("user_pu", "proj1")
for n in (1, 2, 3, 4, 5):
member(f"user_u{n}", "proj1")
member("user_u6", "proj1"); member("user_u6", "proj2", "project_admin") # partly outside super's scope
member("user_u7", "proj2") # wholly outside it
member("user_u8", "proj1"); member("user_u8", "proj4", "project_super_user") # a role super may not grant
ca, cs, cp = client(admin), client(superu), client(pu)
def single_routes():
print("\n0. the single-user routes still behave as before (now on the shared functions)")
r = ca.post("/api/auth/users/user_admin/role", json={"role": "project_user"})
check("changing your own role: 400, same words", r.status_code == 400 and "own role" in r.json()["detail"])
r = ca.post("/api/auth/users/user_admin/active", json={"is_active": False})
check("disabling yourself: 400, same words", r.status_code == 400 and "disable your own" in r.json()["detail"])
r = ca.delete("/api/auth/users/user_admin")
check("deleting yourself: 400, same words", r.status_code == 400 and "delete your own" in r.json()["detail"])
r = cs.post("/api/auth/users/user_u6/role", json={"role": "project_admin"})
check("a super user changing an account outside their scope: 403", r.status_code == 403)
r = cs.put("/api/auth/users/user_u3/projects", json={"project_ids": ["proj1", "proj2"]})
check("a super user assigning a project they don't run: 403", r.status_code == 403)
r = ca.post("/api/auth/users/user_u9/role", json={"role": "project_admin"})
check("a single role change still works and returns the directory row",
r.status_code == 200 and r.json().get("role") == "project_admin")
one = audit("role_changed", "user_u9")
check("...and writes one role_changed row", len(one) == 1 and one[0].detail == {"from": "project_user", "to": "project_admin"},
str([e.detail for e in one]))
ca.post("/api/auth/users/user_u9/role", json={"role": "project_user"})
def bulk_role():
print("\n1. bulk permissions role")
r = ca.post("/api/auth/bulk-users/role", json={
"user_ids": ["user_u1", "user_u2", "user_admin", "user_nobody", "user_u1", "bad id!"],
"role": "project_admin"})
res = by_user(r)
check("200 even though some rows fail (a partial failure is a result, not an error)", r.status_code == 200)
check("u1 and u2 changed", res["user_u1"]["status"] == "ok" and res["user_u2"]["status"] == "ok")
check("your own row is refused with its reason; the rest still ran",
res["user_admin"]["status"] == "failed" and "own role" in res["user_admin"]["reason"])
check("an unknown account is refused as 'User not found'",
res["user_nobody"]["status"] == "failed" and res["user_nobody"]["reason"] == "User not found")
check("a malformed id is refused, not crashed on", res["bad id!"]["status"] == "failed")
check("a duplicated id is applied once", r.json()["requested"] == 5)
check("counts match the rows", (r.json()["ok"], r.json()["failed"]) == (2, 3), str(r.json()))
rows = audit("role_changed", "user_u1")
check("one role_changed audit row per changed account, same shape as the single route",
len(rows) == 1 and rows[0].detail == {"from": "project_user", "to": "project_admin"}
and rows[0].actor == "admin" and rows[0].entity_type == "user", str([e.detail for e in rows]))
r = ca.post("/api/auth/bulk-users/role", json={"user_ids": ["user_u1"], "role": "project_admin"})
check("a row already in that role is 'unchanged' and writes no audit row",
by_user(r)["user_u1"]["status"] == "unchanged" and len(audit("role_changed", "user_u1")) == 1)
r = cs.post("/api/auth/bulk-users/role", json={"user_ids": ["user_u3"], "role": "admin"})
check("a super user cannot grant admin in bulk either (grantable_roles, whole request 400)",
r.status_code == 400)
r = cs.post("/api/auth/bulk-users/role", json={"user_ids": ["user_u3", "user_u6", "user_u7"],
"role": "project_admin"})
res = by_user(r)
check("super user: an account wholly inside their projects changes", res["user_u3"]["status"] == "ok")
check("super user: an account also on a project they don't run is refused, with the reason",
res["user_u6"]["status"] == "failed" and "don't administer" in res["user_u6"]["reason"],
res["user_u6"]["reason"])
check("super user: an account they cannot see is 'User not found' (no existence leak)",
res["user_u7"]["status"] == "failed" and res["user_u7"]["reason"] == "User not found")
r = ca.post("/api/auth/bulk-users/role", json={"user_ids": ["user_admin2"], "role": "project_user"})
check("demoting another admin works while one active admin remains (the caller)",
by_user(r)["user_admin2"]["status"] == "ok")
def bulk_active():
print("\n2. bulk activate / disable")
r = ca.post("/api/auth/bulk-users/active", json={"user_ids": ["user_u4", "user_admin", "user_u5"],
"is_active": False})
res = by_user(r)
check("u4 and u5 disabled", res["user_u4"]["status"] == "ok" and res["user_u5"]["status"] == "ok"
and not fresh().get(models.User, "user_u4").is_active)
check("your own account is refused on its own row",
res["user_admin"]["status"] == "failed" and "disable your own" in res["user_admin"]["reason"])
check("one user_disabled audit row each, same shape as the single route",
[e.detail for e in audit("user_disabled", "user_u4")] == [{"is_active": False}])
r = ca.post("/api/auth/bulk-users/active", json={"user_ids": ["user_u4", "user_u2"], "is_active": True})
res = by_user(r)
check("re-enable: u4 ok, u2 (already active) unchanged",
res["user_u4"]["status"] == "ok" and res["user_u2"]["status"] == "unchanged")
def bulk_projects():
print("\n3. bulk project add / remove")
r = cs.post("/api/auth/bulk-users/projects", json={"user_ids": ["user_u1", "user_u2", "user_u8"],
"project_id": "proj1", "op": "add", "role": "project_admin"})
res = by_user(r)
check("add with a per-project role: every row ok", all(res[u]["status"] == "ok" for u in ("user_u1", "user_u2", "user_u8")),
str(res))
check("the role landed on that project", roles_of("user_u1").get("proj1") == "project_admin")
check("the user's OTHER project and its role are untouched - even a role the caller could not grant",
roles_of("user_u8").get("proj4") == "project_super_user", str(roles_of("user_u8")))
rows = audit("project_access_changed", "user_u1")
check("one project_access_changed row per account, in the single route's shape",
len(rows) == 1 and set(rows[0].detail) == {"projects", "scope", "overrides"}
and rows[0].detail["scope"] == "managed", str([e.detail for e in rows]))
r = cs.post("/api/auth/bulk-users/projects", json={"user_ids": ["user_u1"], "project_id": "proj2", "op": "add"})
check("a super user cannot add anyone to a project they don't run (403)", r.status_code == 403)
r = cs.post("/api/auth/bulk-users/projects", json={"user_ids": ["user_u1"], "project_id": "proj1",
"op": "add", "role": "project_super_user"})
check("a super user cannot hand out super user on a project (400)", r.status_code == 400)
r = ca.post("/api/auth/bulk-users/projects", json={"user_ids": ["user_u6"], "project_id": "proj3", "op": "add"})
check("admin adds u6 to proj3; proj1 and proj2 memberships and roles stay",
by_user(r)["user_u6"]["status"] == "ok"
and roles_of("user_u6") == {"proj1": "", "proj2": "project_admin", "proj3": ""}, str(roles_of("user_u6")))
r = cs.post("/api/auth/bulk-users/projects", json={"user_ids": ["user_u2", "user_u9"], "project_id": "proj1", "op": "remove"})
res = by_user(r)
check("remove: u2 taken off proj1", res["user_u2"]["status"] == "ok" and "proj1" not in roles_of("user_u2"))
check("remove: someone not on it is 'User not found' to a super user who cannot see them",
res["user_u9"]["status"] == "failed")
r = ca.post("/api/auth/bulk-users/projects", json={"user_ids": ["user_u9"], "project_id": "proj1", "op": "remove"})
check("remove: an admin removing someone not on the project gets 'unchanged'",
by_user(r)["user_u9"]["status"] == "unchanged")
r = ca.post("/api/auth/bulk-users/projects", json={"user_ids": ["user_u1"], "project_id": "proj1", "op": "replace"})
check("only add and remove exist: no replace-the-whole-list (400)", r.status_code == 400)
def bulk_delete():
print("\n4. bulk delete")
r = ca.post("/api/auth/bulk-users/delete", json={"user_ids": ["user_u5", "user_admin", "user_gone"]})
res = by_user(r)
check("u5 deleted", res["user_u5"]["status"] == "ok" and fresh().get(models.User, "user_u5") is None)
check("your own account is refused on its own row, the others still ran",
res["user_admin"]["status"] == "failed" and "delete your own" in res["user_admin"]["reason"])
check("an account that no longer exists is reported, not hidden",
res["user_gone"]["status"] == "failed" and res["user_gone"]["reason"] == "User not found")
check("one user_deleted audit row, same shape as the single route",
[e.detail for e in audit("user_deleted", "user_u5")] == [{"role": "project_user"}])
check("the deleted account's memberships went with it", roles_of("user_u5") == {})
def csv_resolve():
print("\n6. CSV upload: usernames in, a line-by-line report out (T12.4)")
text = ("username\n" # header, skipped
"u3\n"
"U3\n" # same person, different case: a duplicate
"nobody\n"
"\n" # blank lines are not rows
"u6\n" # visible to the super user, but also on a project they don't run
"u7\n" # not visible to the super user at all
"super\n" # the caller themself
"u8@example.test,extra column\n" # an email address, matched to exactly one account
",\n") # an empty first column
r = cs.post("/api/auth/bulk-users/resolve", json={"text": text})
j = r.json()
rows = {x["line"]: x for x in j["rows"]}
check("200 with a row for every non-blank line after the header",
r.status_code == 200 and sorted(rows) == [2, 3, 4, 6, 7, 8, 9, 10], sorted(rows))
check("a valid username is accepted", rows[2]["status"] == "ok" and rows[2]["user_id"] == "user_u3")
check("a repeated username is rejected as a duplicate of its first line, not applied twice",
rows[3]["status"] == "rejected" and rows[3]["reason"] == "duplicate of line 2")
check("an unknown username: 'User not found', with its line number", rows[4]["reason"] == "User not found")
check("an account the caller may not change: rejected with the single route's own reason",
rows[6]["status"] == "rejected" and "don't administer" in rows[6]["reason"], rows[6]["reason"])
check("an account the caller cannot see: 'User not found' (a CSV leaks no more than the table)",
rows[7]["reason"] == "User not found")
check("the caller's own account is rejected with a clear reason", "your own account" in rows[8]["reason"])
check("an email address resolves when exactly one account has it",
rows[9]["status"] == "ok" and rows[9]["user_id"] == "user_u8")
check("an empty first column is rejected, not skipped", rows[10]["reason"] == "no username in the first column")
check("the ids handed back are exactly the accepted rows",
j["user_ids"] == ["user_u3", "user_u8"] and (j["accepted"], j["rejected"]) == (2, 6), str(j["user_ids"]))
r = cs.post("/api/auth/bulk-users/active", json={"user_ids": j["user_ids"] + ["user_u7"], "is_active": False})
res = by_user(r)
check("the CSV's ids go through the same bulk route and the same guards: an id slipped in by hand "
"is still refused", res["user_u7"]["status"] == "failed" and res["user_u3"]["status"] == "ok")
ca.post("/api/auth/bulk-users/active", json={"user_ids": ["user_u3", "user_u8"], "is_active": True})
r = cp.post("/api/auth/bulk-users/resolve", json={"text": "u3"})
check("a plain project user cannot resolve a list (403)", r.status_code == 403)
r = cs.post("/api/auth/bulk-users/resolve", json={"text": "x" * 200_001})
check("an oversized upload is refused (422)", r.status_code == 422)
s = fresh()
s.add(models.User(id="user_twin1", username="twin1", email="shared@example.test"))
s.add(models.User(id="user_twin2", username="twin2", email="shared@example.test"))
s.commit()
r = ca.post("/api/auth/bulk-users/resolve", json={"text": "shared@example.test"})
check("an email shared by two accounts matches neither", r.json()["rows"][0]["reason"] == "User not found")
def gates():
print("\n7. who may call, and how much")
for path, body in (("role", {"role": "project_user"}), ("active", {"is_active": False}),
("projects", {"project_id": "proj1", "op": "add"}), ("delete", {})):
r = cp.post(f"/api/auth/bulk-users/{path}", json={"user_ids": ["user_u3"], **body})
check(f"a plain project user is refused /bulk-users/{path} (403)", r.status_code == 403, str(r.status_code))
anon = TestClient(A.app, base_url="http://127.0.0.1", raise_server_exceptions=False)
check("no session: 401", anon.post("/api/auth/bulk-users/delete", json={"user_ids": ["user_u3"]}).status_code == 401)
r = ca.post("/api/auth/bulk-users/active", json={"user_ids": [f"user_x{i}" for i in range(501)], "is_active": False})
check("more than 500 ids in one request is refused (422)", r.status_code == 422, str(r.status_code))
SECTIONS = [single_routes, bulk_role, bulk_active, bulk_projects, bulk_delete, csv_resolve, gates]
def main() -> int:
print("Wave 12 bulk user administration - server checks")
try:
for section in SECTIONS:
try:
section()
except Exception as exc: # noqa: BLE001 - a missing route must read as FAIL, not a traceback
check(f"section {section.__name__} ran to the end", False, f"{type(exc).__name__}: {exc}")
finally:
db.close()
A.engine.dispose()
shutil.rmtree(TMP, ignore_errors=True)
passed = sum(RESULTS)
print(f"\n{passed}/{len(RESULTS)} checks passed.")
return 0 if passed == len(RESULTS) else 1
if __name__ == "__main__":
sys.exit(main())

View File

@@ -0,0 +1,197 @@
#!/usr/bin/env python3
"""CR-020 (wave 12): bulk user administration in the browser, at 1440px and 390px.
python tests/bulk_users_ui_check.py
Self-contained like the other probes: a throwaway SQLite database seeded by
browser_check.seed(), its own uvicorn, headless Edge or Chrome over CDP. Your
real wpsuite.db is never touched. Run it alone, not back to back with another
probe (file-map.md: chained runs exhaust the browser's ports).
The server rules are proven in tests/bulk_users_check.py without a browser.
This file proves the page: selection, the toolbar, the CSV path and the typed
delete, end to end against the real server, operable by keyboard, and holding
together at 390px. It writes the after-screenshots CLAUDE.md asks for to
docs/reference/baseline/wave-12/; the before-shots are the existing
users-1440.png and after-wave9/users-390.png.
Exit 0 all passed, 1 a failure, 2 could not run.
"""
import json
import os
import sys
import tempfile
import time
import urllib.request
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import cdp # noqa: E402
from browser_check import seed, start_server, chk, _PASS, _FAIL # noqa: E402
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
SHOTS = os.path.join(ROOT, "docs", "reference", "baseline", "wave-12")
READY = "!!document.querySelector('#users-table table')"
def api(base, path, token):
req = urllib.request.Request(base + path, headers={"Cookie": "wp_session=" + token})
with urllib.request.urlopen(req, timeout=10) as r:
return json.loads(r.read().decode())
def user(base, token, username):
return next((u for u in api(base, "/api/auth/users", token) if u["username"] == username), None)
def press(page, key, code, vk):
"""A REAL key event (Input.dispatchKeyEvent), not a synthetic KeyboardEvent:
only a real one triggers a checkbox's native Space toggle - the lesson
launcher_check.py records."""
for t in ("keyDown", "keyUp"):
page.ws.call("Input.dispatchKeyEvent", {"type": t, "key": key, "code": code,
"windowsVirtualKeyCode": vk, "text": " " if t == "keyDown" else ""})
time.sleep(0.3)
def answer(page, ok=True, typed=None):
time.sleep(0.4)
if typed is not None:
page.eval("document.getElementById('wp-dlg-input').value=%s" % json.dumps(typed))
page.eval("document.getElementById('%s').click()" % ("wp-dlg-ok" if ok else "wp-dlg-cancel"))
time.sleep(1.2)
def tick(page, username):
page.eval("(() => { const b=[...document.querySelectorAll('input.selbox')]"
".find(x => x.dataset.id==='user_%s'); if(b) b.click(); })()" % username)
time.sleep(0.2)
BAR_390 = """(function(){
var bar=document.getElementById('bulk-bar'); var out={sw:document.documentElement.scrollWidth,under:[],clipped:[],n:0};
bar.querySelectorAll('button, select').forEach(function(el){
var r=el.getBoundingClientRect(); if(!r.width||!r.height) return; out.n++;
var id=el.tagName+' '+(el.textContent||el.id).trim().slice(0,20)+' '+Math.round(r.width)+'x'+Math.round(r.height);
if(Math.min(r.width,r.height)<24) out.under.push(id);
if(r.left<-2||r.right>392) out.clipped.push(id);
});
return JSON.stringify(out);
})()"""
def main():
exe = cdp.find_browser()
if not exe:
print("no headless-capable browser found; set WP_BROWSER.")
return 2
tmpdir = tempfile.mkdtemp(prefix="wpsuite-bulkui-")
db_path = os.path.join(tmpdir, "check.db")
server = browser = None
try:
tok = seed(db_path)
port = cdp.free_port()
base = "http://127.0.0.1:%d" % port
server = start_server(port, db_path)
if server is None:
print("server would not start")
return 2
browser = cdp.Browser(exe)
page = browser.page()
def visit(who, width, mobile=False):
page.clear_cookies()
page.set_cookie("wp_session", tok[who])
page.viewport(width, 900 if width > 500 else 844, mobile=mobile)
page.goto(base + "/users.html", wait_for=READY)
time.sleep(0.6)
print("\n1. the admin at 1440px")
visit("root", 1440)
page.screenshot(os.path.join(SHOTS, "users-1440.png"))
chk("a selection column with select-all", page.eval("!!document.getElementById('sel-all')"))
chk("no bulk bar until a row is selected", page.eval("document.getElementById('bulk-bar').hidden"))
page.eval("document.querySelector('input.selbox[data-id=\"user_pat\"]').focus()")
press(page, " ", "Space", 32)
chk("Space on a focused row checkbox selects it (keyboard operable)",
page.eval("document.querySelector('input.selbox[data-id=\"user_pat\"]').checked"))
chk("the bar appears, reachable by keyboard",
page.eval("!document.getElementById('bulk-bar').hidden && document.querySelector('#bulk-bar button').tabIndex >= 0"))
tick(page, "legacy")
chk("the bar counts the selection", page.eval("document.getElementById('bulk-count').textContent") == "2 selected")
page.screenshot(os.path.join(SHOTS, "users-1440-selected.png"))
page.eval("document.getElementById('bulk-role').value='project_admin';"
"document.querySelector('[onclick=\"bulkRole()\"]').click()")
time.sleep(0.4)
chk("the confirm names the count", "for 2 users" in (page.eval("document.getElementById('wp-dlg-msg').textContent") or ""))
answer(page)
chk("both accounts changed on the server",
user(base, tok["root"], "pat")["role"] == "project_admin" and user(base, tok["root"], "legacy")["role"] == "project_admin")
chk("the result is announced", "2 changed" in page.eval("document.getElementById('bulk-banner').textContent")
and page.eval("document.getElementById('bulk-banner').getAttribute('role')") in ("status", "alert"))
tick(page, "pat")
page.eval("const f=document.getElementById('user-filter'); f.value='active'; f.dispatchEvent(new Event('change'))")
time.sleep(0.3)
chk("changing the filter clears the selection, and says so",
page.eval("document.getElementById('bulk-bar').hidden") and
"filter changed" in page.eval("document.getElementById('sel-banner').textContent"))
print("\n2. the super user, a CSV with good and bad lines")
visit("sue", 1440)
page.eval("loadCsv(new File(['username\\npat\\nmix\\nbob\\nsue\\npat\\n'], 'list.csv', {type:'text/csv'}))")
time.sleep(1.5)
rep = page.eval("document.getElementById('csv-banner').textContent") or ""
chk("only the account she may change is selected", page.eval("document.getElementById('bulk-count').textContent") == "1 selected", rep)
chk("every bad line is reported by number and reason: another job, not found, herself, a duplicate",
all(s in rep for s in ("Line 3 (mix)", "Line 4 (bob): User not found", "Line 5 (sue)", "Line 6 (pat): duplicate of line 2")), rep)
page.eval("document.getElementById('bulk-project-role').value='project_admin';"
"document.querySelector('[onclick=\"bulkProject(\\'add\\')\"]').click()")
answer(page)
roles = api(base, "/api/auth/users/user_pat/projects", tok["root"])["roles"]
chk("add to project with a role landed on the server", roles.get("projA") == "project_admin", roles)
print("\n3. bulk delete needs the typed word")
visit("root", 1440)
tick(page, "bob")
page.eval("document.querySelector('[onclick=\"bulkDelete()\"]').click()")
time.sleep(0.4)
chk("the dialog lists the username", "bob" in page.eval("document.getElementById('wp-dlg-msg').textContent"))
page.eval("document.getElementById('wp-dlg-input').value='delete'; document.getElementById('wp-dlg-ok').click()")
time.sleep(0.4)
chk("a wrong word sends nothing", user(base, tok["root"], "bob") is not None
and page.eval("document.getElementById('wp-dlg-overlay').classList.contains('open')"))
answer(page, typed="DELETE")
chk("DELETE deletes, and the report says so", user(base, tok["root"], "bob") is None
and "1 changed" in page.eval("document.getElementById('bulk-banner').textContent"))
print("\n4. the gloved-hands width: 390px")
visit("root", 390, mobile=True)
page.screenshot(os.path.join(SHOTS, "users-390.png"))
tick(page, "pat")
m = json.loads(page.eval(BAR_390))
page.screenshot(os.path.join(SHOTS, "users-390-selected.png"))
chk("390px with the bar open: no sideways scrolling", m["sw"] <= 392, m["sw"])
chk("390px: no bar control clipped past the screen", not m["clipped"], m["clipped"])
chk("390px: every bar control meets the 24px floor", m["n"] > 0 and not m["under"], m["under"])
errs = [e for e in page.js_errors() if "beforeunload" not in e]
chk("no JavaScript errors in the whole run", not errs, errs[:3])
finally:
if browser is not None:
try:
browser.close()
except Exception:
pass
if server is not None:
server.terminate()
print("\n" + "-" * 54)
print("%d/%d checks passed." % (len(_PASS), len(_PASS) + len(_FAIL)))
for f in _FAIL:
print(" - " + f)
return 1 if _FAIL else 0
if __name__ == "__main__":
sys.exit(main())

View File

@@ -190,8 +190,26 @@ class Browser:
f"--user-data-dir={self.profile}", "--remote-allow-origins=*",
"--no-first-run", "--no-default-browser-check", "--disable-gpu",
"--disable-extensions", "--disable-sync",
"--window-size=1400,1000", "about:blank"],
"--window-size=1400,1000"]
# Run from an elevated (Administrator) shell, Edge and Chrome
# "de-elevate": they relaunch themselves as a normal user through
# Explorer and the launched process exits rc=0. The relaunch does
# not keep the debugging port, so the port is never bound (found
# 2026-10-02; Edge logs "Edge is running elevated: 1"). This
# Chromium switch keeps the process we started. Ignored when the
# shell is not elevated, and on other platforms.
+ (["--do-not-de-elevate"] if sys.platform == "win32" else [])
+ ["about:blank"],
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
# On some Windows installs msedge.exe is a launcher: it starts the real
# browser and exits rc=0 at once, and the real browser binds the port a
# moment later. Giving up the instant the launched process exited
# failed every attempt on such a machine although Edge worked when
# started by hand (found 2026-10-02 running the wave 16 probes). An
# rc=0 exit now gets a grace period to bind; a non-zero exit is still
# a failure at once. Teardown is unaffected: close() sweeps by the
# unique profile path, which also catches the handed-off process.
exited_at = None
for _ in range(160):
try:
with urllib.request.urlopen(
@@ -199,9 +217,14 @@ class Browser:
json.load(r)
return
except Exception:
if self.proc.poll() is not None:
last = f"exited rc={self.proc.returncode} without binding the port"
break
rc = self.proc.poll()
if rc is not None:
last = f"exited rc={rc} without binding the port"
if rc != 0:
break
exited_at = exited_at or time.time()
if time.time() - exited_at > 15:
break
time.sleep(0.25)
else:
last = "never bound the debugging port"

View File

@@ -8,9 +8,17 @@ They now go through `wp-dialog.js` — the T7.9 kit extracted as a shared,
self-injecting component (guarded so the creator's inline copy still wins on
its own page).
Static half greps the counts; browser half drives the password-reset prompt on
the users console with natives poisoned, and proves validate() answers AT the
input while the server round-trip completes end to end.
Static half greps the counts; browser half drives the users console's dialogs
with natives poisoned and proves they still work end to end.
Used to drive this via the password-reset prompt specifically, because it was
the one place on this page exercising wp-dialog.js's PROMPT variant (text input
+ client-side validate()) rather than its confirm variant. T10.4 (D15/D16)
removed admin password reset entirely — there is no password to reset anymore
— so that coverage moved with it. The prompt-with-validate() pattern itself is
still exercised, just not on this page: see creator_dialogs_check.py for
wp-creation-app.js's own wpPromptDialog() call sites. If users.html ever grows
a new prompt-style dialog, it belongs back in this file.
Boots its own throwaway SQLite + uvicorn + headless browser; run it alone.
Exit 0 all passed, 1 a failure, 2 could not run.
@@ -91,31 +99,6 @@ def main():
chk("the console booted with a user table",
page.eval("!!document.querySelector('table')"))
page.eval("void resetPw('user_pat','pat')")
time.sleep(0.4)
chk("the reset prompt is the kit's modal, open, focused at the input",
page.eval("(() => { const o=document.getElementById('wp-dlg-overlay');"
" return !!o && o.classList.contains('open')"
" && document.activeElement.id==='wp-dlg-input'; })()"))
page.eval("document.getElementById('wp-dlg-input').value='short';"
"document.getElementById('wp-dlg-ok').click()")
chk("a short password is refused AT the input - dialog stays, error says why",
page.eval("(() => { const o=document.getElementById('wp-dlg-overlay');"
" return o.classList.contains('open')"
" && /12 characters/.test(document.getElementById('wp-dlg-err').textContent); })()"))
page.eval("document.getElementById('wp-dlg-input').value='CorrectHorseBattery10';"
"document.getElementById('wp-dlg-ok').click()")
time.sleep(1.2)
chk("a good answer closes the dialog and the server accepts it",
page.eval("!document.getElementById('wp-dlg-overlay').classList.contains('open')"))
chk("...announced through the kit's toast (role=status)",
page.eval("(() => { const t=document.getElementById('toast');"
" return !!t && t.getAttribute('role')==='status'"
" && /Password reset for pat/.test(t.textContent); })()"))
st, _ = api(base, "/api/auth/login", "x", "POST",
{"username": "pat", "password": "CorrectHorseBattery10"})
chk("...and the new password actually works", st == 200, st)
print("\n3. destroy needs a real yes")
page.eval("void deleteUser('user_bob','bob')")
time.sleep(0.4)
@@ -129,6 +112,33 @@ def main():
chk("cancel means no: bob is still an account",
st == 200 and any(u.get("username") == "bob" for u in (users or [])),
ascii_([u.get("username") for u in (users or [])]))
# CR-020 / T12.5: the bulk delete is a PROMPT-style dialog (typed DELETE),
# the kind this file's docstring says belongs back here.
print("\n4. bulk delete needs the typed word")
page.eval("(() => { const b=[...document.querySelectorAll('input.selbox')]"
".find(x => x.dataset.id==='user_bob'); b.click(); })()")
time.sleep(0.3)
chk("ticking a row shows the bulk bar",
page.eval("!document.getElementById('bulk-bar').hidden"))
page.eval("document.querySelector('[onclick=\"bulkDelete()\"]').click()")
time.sleep(0.4)
chk("the bulk delete asks through the kit's prompt, listing the username",
page.eval("(() => { const o=document.getElementById('wp-dlg-overlay');"
" return o.classList.contains('open')"
" && document.getElementById('wp-dlg-input-wrap').style.display !== 'none'"
" && /bob/.test(document.getElementById('wp-dlg-msg').textContent); })()"))
page.eval("document.getElementById('wp-dlg-input').value='delete';"
"document.getElementById('wp-dlg-ok').click()")
time.sleep(0.3)
chk("the wrong word keeps it open and names what to type",
page.eval("document.getElementById('wp-dlg-overlay').classList.contains('open')"
" && /DELETE/.test(document.getElementById('wp-dlg-err').textContent)"))
page.eval("document.getElementById('wp-dlg-cancel').click()")
time.sleep(0.6)
st, users = api(base, "/api/auth/users", tok["root"])
chk("cancel means no: bob is still an account after the bulk prompt",
st == 200 and any(u.get("username") == "bob" for u in (users or [])))
errs = [e for e in page.js_errors() if "beforeunload" not in e]
chk("no JavaScript errors, and no path reached a native dialog (they throw here)",
not errs, ascii_(errs[:3]))

View File

@@ -31,7 +31,7 @@ sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import cdp # noqa: E402
from browser_check import seed, start_server, chk, _PASS, _FAIL, _c, PW # noqa: E402
from browser_check import seed, start_server, chk, _PASS, _FAIL, _c # noqa: E402
STUB = """
window.__dialogs = [];
@@ -55,8 +55,7 @@ def seed_empty(db_path):
Base.metadata.create_all(bind=engine)
with SessionLocal() as db:
db.add(models.User(id="user_new", username="new", email="new@example.test",
full_name="New Starter", password_hash=auth.hash_password(PW),
role=auth.ROLE_ADMIN))
full_name="New Starter", role=auth.ROLE_ADMIN))
db.commit()
return {u.username: auth.create_token(u) for u in db.query(models.User).all()}

View File

@@ -323,6 +323,13 @@ def run(page, base, tok):
{"text": "Probe Building One,Probe Level 1,Probe Sector B"})
chk("the import reports it as reactivated, not created or duplicate",
len(again["body"]["reactivated"]) == 1 and not again["body"]["created"], again["body"])
# The 2026-08-23 production 500, pinned (locations side): Postgres-refused
# values reject by line, on every dialect, never crash the request.
hz = api(page, "POST", "/api/projects/projA/locations/import",
{"text": "Probe Building One," + "Y" * 220 + ",S1", "dry_run": True})
chk("an over-long name is a line rejection, not a 500",
hz["status"] == 200 and hz["body"]["rejected"]
and "200 characters" in hz["body"]["rejected"][0]["reason"], hz["body"])
same = [n for n in api(page, "GET",
"/api/projects/projA/locations?include_inactive=true")["body"]["nodes"]
if n["path"] == sec["path"]]

View File

@@ -105,6 +105,20 @@ def main():
_, listing = api(base, "/api/projects/projA/materials", root)
chk("...and nothing was written", listing["items"] == [])
# The 2026-08-23 production 500, pinned: what Postgres refuses (VARCHAR
# overflow, control bytes) must come back as a per-line rejection - on
# EVERY dialect - never crash the request.
code, rep = api(base, "/api/projects/projA/materials/import", root, "POST",
{"text": "Sample " + "x" * 300 + ",EA", "dry_run": True})
chk("an over-long description is a line rejection, not a 500",
code == 200 and rep["rejected"] and "300 characters" in rep["rejected"][0]["reason"]
and not rep["created"], ascii_(rep))
code, rep = api(base, "/api/projects/projA/materials/import", root, "POST",
{"text": "Sample widget\u0000,EA", "dry_run": True})
chk("a control byte is a line rejection, not a 500",
code == 200 and rep["rejected"]
and "control characters" in rep["rejected"][0]["reason"], ascii_(rep))
code, rep = api(base, "/api/projects/projA/materials/import", root, "POST",
{"text": text, "dry_run": False})
_, listing = api(base, "/api/projects/projA/materials", root)

327
tests/okta_auth_check.py Normal file
View File

@@ -0,0 +1,327 @@
#!/usr/bin/env python3
"""Does Okta sign-in hold its guarantees? — D15/D16 / T10.7.
The Okta equivalent of tests/ldap_auth_check.py (D13's predecessor). Covers the
things that would still let the app *look* fine while quietly failing:
1. The fake provider must be impossible to select against a real database.
2. A one-time authorization code cannot be redeemed twice (replay).
3. An unsolicited hit on the callback (no real login ever started) is refused,
not a 500 — and creates no account.
4. A denied ("Cancel") consent is refused cleanly (?error=cancelled) and
creates no account.
5. An unknown fake identity at consent is refused and creates no account.
6. A correct sign-in works, and ?next= carries through to the real target —
but only when it is a same-site path; an off-site next= is ignored.
7. A disabled local account is refused even though Okta itself approved it —
deprovisioning stays local (D15).
8. An unrecognized identity is JIT-provisioned at the lowest role.
9. An existing admin signs in and is STILL an admin, with their locally-set
name intact — Okta never overwrites what this app already knows.
10. OKTA_IDENTITY_CLAIM is genuinely configurable: sign-in still works with a
non-default claim name, proving T10.3's "no hard-coded claim" promise.
Self-contained: throwaway SQLite + its own uvicorn. No browser, no live Okta —
server/okta_fake.py stands in for the provider. Two layers, like its LDAP
predecessor: guards that need no server (direct calls into okta_fake), then
sign-in checks against a real running app.
Exit 0 all passed, 1 a failure, 2 could not run.
"""
import json
import os
import re
import subprocess
import sys
import tempfile
import time
import urllib.error
import urllib.request
from http.cookiejar import CookieJar
from urllib.parse import quote, urlparse
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from cdp import free_port # noqa: E402
_PASS, _FAIL = [], []
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
def chk(label, ok, detail=""):
(_PASS if ok else _FAIL).append(label)
print(f" {'PASS' if ok else 'FAIL'} {label}" + ("" if ok else f" {detail}"))
def users_in(db_path):
"""Read the users table straight out of the given file. Deliberately NOT
via server.db.SessionLocal — that engine binds from DATABASE_URL at import,
so setting the env var later keeps reading whichever file came first. The
LDAP predecessor lost two assertions to exactly this before it was noticed."""
import sqlite3
con = sqlite3.connect(db_path)
try:
try:
return {r[0]: (r[1], r[2], bool(r[3]))
for r in con.execute(
"select username, role, full_name, is_active from users")}
except sqlite3.OperationalError:
return {}
finally:
con.close()
def start(port, db_path, fake, identity_claim=None):
env = dict(os.environ)
env["DATABASE_URL"] = "sqlite:///" + db_path.replace("\\", "/")
env["AUTH_SECRET_KEY"] = "okta-auth-check-not-for-production"
env["WP_OKTA_FAKE_DIRECTORY"] = json.dumps(fake)
if identity_claim:
env["OKTA_IDENTITY_CLAIM"] = identity_claim
else:
env.pop("OKTA_IDENTITY_CLAIM", None)
proc = subprocess.Popen(
[sys.executable, "-m", "uvicorn", "server.app:app", "--host", "127.0.0.1",
"--port", str(port), "--log-level", "warning"],
env=env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, cwd=ROOT)
for _ in range(160):
try:
with urllib.request.urlopen(f"http://127.0.0.1:{port}/api/health", timeout=1):
return proc
except Exception:
if proc.poll() is not None:
return None
time.sleep(0.25)
proc.kill()
return None
def opener():
return urllib.request.build_opener(
urllib.request.HTTPCookieProcessor(CookieJar()))
def fetch(op, url):
"""GET, auto-following redirects (urllib's default) — matches what a real
browser does across the login -> fake-provider -> callback -> target chain.
Returns (final_url, status, body)."""
try:
with op.open(url, timeout=10) as r:
return r.geturl(), r.status, r.read().decode("utf-8", "replace")
except urllib.error.HTTPError as e:
return e.geturl(), e.code, e.read().decode("utf-8", "replace")
def sign_in(base, op, username, next_path=None):
"""Drive the real round trip: /api/auth/okta/login -> the fake provider's
picker page -> consent as `username` -> okta_callback(). Every hop except
the fake provider itself is the app's own unmodified code."""
login_url = base + "/api/auth/okta/login"
if next_path:
login_url += "?next=" + quote(next_path, safe="")
final_url, status, body = fetch(op, login_url)
if "_fake_provider" not in final_url:
return final_url, status, body # never reached the fake at all
m = re.search(
r'id="okta-fake-identity-%s" href="([^"]+)"' % re.escape(username), body)
if not m:
return final_url, status, body # identity not offered
consent_url = base + m.group(1).replace("&amp;", "&")
return fetch(op, consent_url)
def deny(base, op):
_, _, body = fetch(op, base + "/api/auth/okta/login")
m = re.search(r'id="okta-fake-deny" href="([^"]+)"', body)
if not m:
return None, None, body
return fetch(op, base + m.group(1).replace("&amp;", "&"))
def consent_as(base, op, username, state_override=None):
"""Reach the consent endpoint directly with an arbitrary `username` (which
need not be one the picker actually offered) and, optionally, a `state`
that does not match the one the login step stashed in the session — so
'unknown identity' and 'tampered state' can be tested as the server's own
refusal, not merely as absence from the picker's list."""
_, _, body = fetch(op, base + "/api/auth/okta/login")
m = re.search(r'id="okta-fake-deny" href="([^"]+)"', body)
if not m:
return None, None, body
href = m.group(1).replace("&amp;", "&").replace("deny=1", "username=" + quote(username))
if state_override is not None:
href = re.sub(r"state=[^&]*", "state=" + quote(state_override), href)
return fetch(op, base + href)
def main():
print("1. the guards that do not need a server")
os.environ["DATABASE_URL"] = "sqlite:///./_oktacheck_unit.db"
os.environ["WP_OKTA_FAKE_DIRECTORY"] = json.dumps({"root": {"email": "r@x.test", "name": "R"}})
from server import okta_fake
chk("the fake is active against a SQLite database", okta_fake.is_active())
out = subprocess.run(
[sys.executable, "-c",
"from server import okta_fake; print(okta_fake.is_active())"],
cwd=ROOT, capture_output=True, text=True,
env={**os.environ,
"DATABASE_URL": "postgresql+psycopg://u:p@localhost:5432/db",
"AUTH_SECRET_KEY": "x",
"WP_OKTA_FAKE_DIRECTORY": json.dumps({"root": {"email": "r@x.test"}})})
chk("the fake provider REFUSES to work against a non-SQLite database",
out.stdout.strip() == "False", out.stdout.strip() or out.stderr[-200:])
code = okta_fake.new_code({"preferred_username": "root"})
first = okta_fake.consume_code(code)
second = okta_fake.consume_code(code)
chk("a fresh code redeems once", first == {"preferred_username": "root"}, first)
chk("...and a REPLAYED code is refused the second time", second is None, second)
print("\n2. sign-in, against a server")
db_fd, db_path = tempfile.mkstemp(suffix=".db"); os.close(db_fd)
port = free_port()
fake = {"root": {"email": "root@example.test", "name": "Root Person"},
"newperson": {"email": "newperson@example.test", "name": "New Person"}}
server = start(port, db_path, fake)
if server is None:
print("the test server would not start.")
return 2
base = f"http://127.0.0.1:{port}"
try:
# Seed one pre-existing admin and one pre-existing but disabled account,
# the same way manage_users.py / the admin console would have left them.
import sqlalchemy as _sa
from server.db import Base
from server import models # noqa: F401
eng = _sa.create_engine("sqlite:///" + db_path.replace("\\", "/"))
Base.metadata.create_all(bind=eng)
with eng.begin() as con:
con.execute(_sa.text(
"insert into users (id,username,email,full_name,role,is_active,"
"failed_attempts,token_version,project_role,locale,timezone,"
"auto_add_projects,auto_add_role,created_at,updated_at) values "
"('user_root','root','','Set By Hand','admin',1,0,0,'','','',0,'',"
"datetime('now'),datetime('now'))"))
con.execute(_sa.text(
"insert into users (id,username,email,full_name,role,is_active,"
"failed_attempts,token_version,project_role,locale,timezone,"
"auto_add_projects,auto_add_role,created_at,updated_at) values "
"('user_shelved','shelved','','Shelved Person','project_user',0,0,0,"
"'','','',0,'',datetime('now'),datetime('now'))"))
eng.dispose()
fake["shelved"] = {"email": "shelved@example.test", "name": "Shelved Person"}
# Restart so the running process picks up the augmented directory.
server.kill(); server.wait(timeout=10)
server = start(port, db_path, fake)
if server is None:
print("the test server would not restart with the augmented directory.")
return 2
final_url, status, _ = sign_in(base, opener(), "root")
chk("a seeded identity signs in", status == 200 and urlparse(final_url).path == "/index.html",
(final_url, status))
chk("...and the existing admin is STILL an admin",
users_in(db_path).get("root", ("", "", None))[0] == "admin", users_in(db_path))
chk("...with their locally-set name untouched by Okta",
users_in(db_path).get("root", (None, None))[1] == "Set By Hand", users_in(db_path))
before = set(users_in(db_path))
final_url, status, _ = sign_in(base, opener(), "newperson")
chk("an unrecognized identity is JIT-provisioned", status == 200, (final_url, status))
chk("...at the lowest role", users_in(db_path).get("newperson", ("", "", None))[0]
== "project_user", users_in(db_path).get("newperson"))
chk("...and only one new row appeared",
set(users_in(db_path)) - before == {"newperson"}, set(users_in(db_path)) - before)
final_url, status, _ = sign_in(base, opener(), "shelved")
chk("a disabled local account is refused despite Okta approving it",
"error=disabled" in final_url, final_url)
before = set(users_in(db_path))
final_url, status, _ = consent_as(base, opener(), "nobody-such-identity")
# okta_callback()'s `except OAuthError` is deliberately generic (T10.5:
# a plain-language ?error= for whatever Authlib/the provider rejected,
# not a code-by-code breakdown) — so this lands on the same ?error=
# cancelled as every other refusal, not a distinct "invalid_request".
# The thing actually under test is the SERVER-side refusal, verified by
# checking no account got created — not the display string.
chk("consenting as an identity the fake never offered is refused BY THE SERVER"
" (not just absent from the picker)",
"login.html" in final_url and "error=cancelled" in final_url, final_url)
chk("...and creates nothing", set(users_in(db_path)) == before,
set(users_in(db_path)) - before)
before = set(users_in(db_path))
final_url, status, _ = consent_as(base, opener(), "root", state_override="tampered-state")
chk("a consent hit whose state does not match the session is refused",
"login.html" in final_url and "error=cancelled" in final_url, final_url)
chk("...and creates nothing", set(users_in(db_path)) == before,
set(users_in(db_path)) - before)
before = set(users_in(db_path))
final_url, status, _ = deny(base, opener())
chk("denying consent lands back on login with a plain message",
"login.html" in final_url and "error=cancelled" in final_url, final_url)
chk("...and creates nothing", set(users_in(db_path)) == before,
set(users_in(db_path)) - before)
cold = opener()
final_url, status, _ = fetch(
cold, base + "/api/auth/okta/callback?code=forged&state=forged")
chk("an unsolicited hit on the callback (no login ever started) is refused, not a 500",
status == 200 and "login.html" in final_url and "error=cancelled" in final_url,
(final_url, status))
final_url, status, _ = sign_in(base, opener(), "root", next_path="/wp-creation-index.html?wp=x")
chk("a same-site ?next= survives the round trip",
urlparse(final_url).path == "/wp-creation-index.html"
and "wp=x" in urlparse(final_url).query, final_url)
final_url, status, _ = sign_in(base, opener(), "root", next_path="https://evil.example.com/phish")
chk("an off-site ?next= is ignored, not honoured",
urlparse(final_url).path == "/index.html", final_url)
finally:
server.kill()
try:
server.wait(timeout=10)
except subprocess.TimeoutExpired:
pass
print("\n3. the identity claim name is genuinely configurable (T10.3)")
db_fd2, db2 = tempfile.mkstemp(suffix=".db"); os.close(db_fd2)
port2 = free_port()
server2 = start(port2, db2, {"root": {"email": "root@example.test", "name": "Root"}},
identity_claim="upn")
if server2 is None:
print("the identity-claim test server would not start.")
return 2
try:
base2 = f"http://127.0.0.1:{port2}"
final_url, status, _ = sign_in(base2, opener(), "root")
chk("sign-in works with a non-default OKTA_IDENTITY_CLAIM (upn)",
status == 200 and urlparse(final_url).path == "/index.html", (final_url, status))
chk("...and JIT-provisioned the account under that identity",
users_in(db2).get("root", ("", "", None))[0] == "project_user", users_in(db2))
finally:
server2.kill()
try:
server2.wait(timeout=10)
except subprocess.TimeoutExpired:
pass
print("\n" + "-" * 54)
print(f"{len(_PASS)}/{len(_PASS) + len(_FAIL)} checks passed.")
for f in _FAIL:
print(" - " + f)
return 1 if _FAIL else 0
if __name__ == "__main__":
try:
sys.exit(main())
except Exception as exc: # noqa: BLE001
print(f"could not run: {type(exc).__name__}: {exc}")
sys.exit(2)

252
tests/okta_sync_check.py Normal file
View File

@@ -0,0 +1,252 @@
#!/usr/bin/env python3
"""Does the Okta Management API client keep its promises? - D18 / T13.2.
The one promise that matters: a failure is never an empty list. T13.3 reads an
empty list as "nobody is active", so a client that returned [] when Okta was
down would disable the whole org. Every failure below must raise OktaSyncError.
Also checked: the client uses its own credential (never the OIDC client secret),
follows pagination, never sends the token to another host, never follows a
redirect, and never lets the token reach a log line, an error message, or
describe().
Self-contained: no server, no database, no network, no browser. httpx's
MockTransport stands in for Okta.
Exit 0 all passed, 1 a failure.
"""
import logging
import os
import sys
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, ROOT)
import httpx # noqa: E402
from server import okta_auth, okta_sync # noqa: E402
TOKEN = "00tok-SECRET-api-token-xyz"
CLIENT_SECRET = "oidc-client-SECRET-abc"
ORG = "https://example.okta.com"
fails = 0
def chk(label, ok, extra=""):
global fails
print(("PASS " if ok else "FAIL ") + label + (f" [{extra}]" if (extra and not ok) else ""))
if not ok:
fails += 1
class Capture(logging.Handler):
def __init__(self):
super().__init__()
self.lines = []
def emit(self, record):
self.lines.append(record.getMessage())
cap = Capture()
logging.getLogger("wpsuite").addHandler(cap)
logging.getLogger("wpsuite").setLevel(logging.DEBUG)
def reset_env():
os.environ["OKTA_API_TOKEN"] = TOKEN
os.environ["OKTA_CLIENT_SECRET"] = CLIENT_SECRET
os.environ.pop("OKTA_ORG_URL", None)
os.environ.pop("OKTA_SYNC_PROFILE_ATTRIBUTE", None)
okta_auth.ISSUER = f"{ORG}/oauth2/default"
okta_auth.IDENTITY_CLAIM = "preferred_username"
def user(login, status="ACTIVE", **profile):
p = {"login": login, "email": login}
p.update(profile)
return {"id": "00u" + login, "status": status, "profile": p}
def client(handler):
return httpx.Client(transport=httpx.MockTransport(handler))
def raises(handler, label, **kw):
"""Run fetch_users against `handler`; it must raise OktaSyncError, and the
message must not hold the token."""
reset_env()
try:
out = okta_sync.fetch_users(http=client(handler))
except okta_sync.OktaSyncError as exc:
msg = str(exc)
clean = TOKEN not in msg and CLIENT_SECRET not in msg and "example.okta.com" not in msg
chk(f"{label}: raises, message has no token or host", clean, msg)
return msg
except Exception as exc: # the wrong exception type
chk(f"{label}: raises OktaSyncError", False, f"{type(exc).__name__}: {exc}")
return ""
chk(f"{label}: raises (did NOT raise, returned {out!r})", False)
return ""
def ok(body):
return lambda req: httpx.Response(200, json=body)
# ── 1. a good fetch ───────────────────────────────────────────────────────────
print("\n1. a good fetch")
reset_env()
seen = []
def good(req):
seen.append(req)
return httpx.Response(200, json=[user("alice", "ACTIVE"), user("bob", "suspended")])
users = okta_sync.fetch_users(http=client(good))
chk("returns every user", [u.identity for u in users] == ["alice", "bob"])
chk("status is upper case", [u.status for u in users] == ["ACTIVE", "SUSPENDED"])
chk("asks the users endpoint of the org", str(seen[0].url).startswith(f"{ORG}/api/v1/users"))
chk("asks for the page maximum", seen[0].url.params.get("limit") == "200")
chk("authenticates with the API token (SSWS)", seen[0].headers.get("authorization") == f"SSWS {TOKEN}")
chk("never sends the OIDC client secret", CLIENT_SECRET not in str(seen[0].headers))
# ── 2. pagination ─────────────────────────────────────────────────────────────
print("\n2. pagination")
reset_env()
calls = []
def paged(req):
calls.append(req)
if "after=p2" not in str(req.url):
return httpx.Response(200, json=[user("alice")],
headers={"Link": f'<{ORG}/api/v1/users?limit=200&after=p2>; rel="next"'})
return httpx.Response(200, json=[user("bob")])
users = okta_sync.fetch_users(http=client(paged))
chk("follows the next link and returns both pages", [u.identity for u in users] == ["alice", "bob"])
chk("two requests, no more", len(calls) == 2)
chk("page 2 also carries the token", calls[1].headers.get("authorization") == f"SSWS {TOKEN}")
# ── 3. the failure rule: an error is never an empty list ──────────────────────
print("\n3. every failure raises (never returns an empty list)")
for code in (401, 403, 404, 429, 500, 502, 503):
raises(lambda req, c=code: httpx.Response(c, json={"errorCode": "x"}), f"HTTP {code}")
raises(lambda req: httpx.Response(302, headers={"Location": "https://evil.example/"}), "a redirect (never followed)")
raises(lambda req: (_ for _ in ()).throw(httpx.ConnectError("boom to https://example.okta.com/api/v1/users")), "connection error")
raises(lambda req: (_ for _ in ()).throw(httpx.ReadTimeout("slow")), "timeout")
raises(lambda req: httpx.Response(200, text="<html>not json</html>"), "body is not JSON")
raises(ok({"errorCode": "E0000011"}), "body is an object, not a list")
raises(ok("a string"), "body is a string")
raises(ok([]), "an empty list (not credible for a real org)")
raises(ok(["alice"]), "an item that is not an object")
raises(ok([{"profile": {"login": "a"}}]), "an item with no status")
raises(ok([{"status": "ACTIVE"}]), "an item with no profile")
raises(ok([{"status": "ACTIVE", "profile": {}}]), "an item with no login")
raises(ok([{"status": "ACTIVE", "profile": {"login": " "}}]), "an item with a blank login")
raises(ok([user("alice"), {"status": "ACTIVE", "profile": {}}]), "one bad item among good ones (never skipped)")
# ── 4. misconfiguration raises ────────────────────────────────────────────────
print("\n4. misconfiguration")
reset_env()
os.environ["OKTA_API_TOKEN"] = ""
try:
okta_sync.fetch_users(http=client(good))
chk("no token raises", False)
except okta_sync.OktaSyncError:
chk("no token raises", True)
reset_env()
okta_auth.ISSUER = ""
try:
okta_sync.fetch_users(http=client(good))
chk("no org URL raises", False)
except okta_sync.OktaSyncError:
chk("no org URL raises", True)
reset_env()
os.environ["OKTA_ORG_URL"] = "http://example.okta.com"
sent = []
try:
okta_sync.fetch_users(http=client(lambda r: sent.append(r) or httpx.Response(200, json=[user("a")])))
chk("an http org URL raises", False)
except okta_sync.OktaSyncError:
chk("an http org URL raises", True)
chk("...and no request was made (token never sent over http)", sent == [])
# ── 5. never leaks the token to another host, never loops forever ─────────────
print("\n5. next-link safety")
reset_env()
hosts = []
def evil_link(req):
hosts.append(req.url.host)
return httpx.Response(200, json=[user("alice")],
headers={"Link": '<https://evil.example/steal>; rel="next"'})
raises(evil_link, "a next link to another host")
chk("...the other host was never contacted", hosts == ["example.okta.com"])
count = []
def endless(req):
count.append(1)
return httpx.Response(200, json=[user("alice")],
headers={"Link": f'<{ORG}/api/v1/users?after={len(count)}>; rel="next"'})
raises(endless, "an endless next chain (page cap)")
chk(f"...stops at the cap ({okta_sync.MAX_PAGES} requests)", len(count) == okta_sync.MAX_PAGES, str(len(count)))
# ── 6. org URL and identity attribute ─────────────────────────────────────────
print("\n6. org URL and identity attribute")
reset_env()
chk("org URL is the issuer's scheme and host", okta_sync.org_url() == ORG)
os.environ["OKTA_ORG_URL"] = "https://corp.okta.com/"
chk("OKTA_ORG_URL wins, trailing slash removed", okta_sync.org_url() == "https://corp.okta.com")
reset_env()
okta_auth.IDENTITY_CLAIM = "email"
body = [{"status": "ACTIVE", "profile": {"login": "alice", "email": "alice@x.com"}}]
chk("claim 'email' reads profile.email", okta_sync.fetch_users(http=client(ok(body)))[0].identity == "alice@x.com")
okta_auth.IDENTITY_CLAIM = "sAMAccountName"
body = [{"status": "ACTIVE", "profile": {"login": "alice@x.com", "sAMAccountName": "alice"}}]
chk("a custom claim reads profile[<claim>]", okta_sync.fetch_users(http=client(ok(body)))[0].identity == "alice")
os.environ["OKTA_SYNC_PROFILE_ATTRIBUTE"] = "login"
chk("OKTA_SYNC_PROFILE_ATTRIBUTE overrides", okta_sync.fetch_users(http=client(ok(body)))[0].identity == "alice@x.com")
# ── 7. the token never leaks ──────────────────────────────────────────────────
print("\n7. the token never leaks")
reset_env()
chk("describe() has no token", TOKEN not in okta_sync.describe() and "configured" in okta_sync.describe())
os.environ["OKTA_API_TOKEN"] = ""
chk("describe() says DISABLED without a token", "DISABLED" in okta_sync.describe())
reset_env()
every_log = " ".join(cap.lines)
chk("no log line holds the API token", TOKEN not in every_log)
chk("no log line holds the client secret", CLIENT_SECRET not in every_log)
# ── 8. the whole fetch is time-bounded (T13.4 relies on it) ──────────────────
print("\n8. the whole fetch is time-bounded")
reset_env()
saved = okta_sync.TOTAL_DEADLINE_SECONDS
okta_sync.TOTAL_DEADLINE_SECONDS = 0.0
def slow_pages(req):
return httpx.Response(200, json=[user("alice")],
headers={"Link": f'<{ORG}/api/v1/users?after=x>; rel="next"'})
raises(slow_pages, "a fetch that runs past the total deadline")
okta_sync.TOTAL_DEADLINE_SECONDS = saved
chk("the real deadline is under the shortest allowed interval",
okta_sync.TOTAL_DEADLINE_SECONDS < okta_sync.INTERVAL_MIN_SECONDS)
print()
print("ALL PASSED" if not fails else f"{fails} FAILED")
sys.exit(0 if not fails else 1)

View File

@@ -0,0 +1,277 @@
#!/usr/bin/env python3
"""Does the Okta sync use DPoP correctly? - D24 / T13.10.
A strict fake Okta (httpx.MockTransport) checks every DPoP proof the way RFC 9449 says a
server must: the header (typ dpop+jwt, ES256, a PUBLIC jwk only), the signature against
that jwk, htm, htu (no query), iat, a one-time jti, the nonce when the server asked for
one, and on an API call the ath hash of the access token and the same key as at the token
request. Also: auto mode finds out that DPoP is required, the nonce dance at the token
endpoint and at the API, paging, off mode, bounded retries, and no secret in any message.
Self-contained: no network, no server, no browser. Exit 0 all passed, 1 a failure.
"""
import base64
import hashlib
import json
import os
import sys
import time
from urllib.parse import parse_qs
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, ROOT)
os.environ["DATABASE_URL"] = "sqlite://"
for v in ("OKTA_API_TOKEN", "OKTA_SYNC_PROFILE_ATTRIBUTE", "OKTA_SYNC_DPOP"):
os.environ.pop(v, None)
os.environ["OKTA_ORG_URL"] = "https://example.okta.com"
import httpx # noqa: E402
import jwt # noqa: E402
from cryptography.hazmat.primitives.asymmetric import rsa # noqa: E402
from server import okta_sync # noqa: E402
from server.okta_sync import OktaSyncError # noqa: E402
fails = 0
def chk(label, ok, extra=""):
global fails
print(("PASS " if ok else "FAIL ") + label + (f" [{extra}]" if (extra and not ok) else ""))
if not ok:
fails += 1
pk = rsa.generate_private_key(public_exponent=65537, key_size=2048)
CLIENT_JWK = json.loads(jwt.algorithms.RSAAlgorithm.to_jwk(pk))
CLIENT_JWK.update({"kid": "k1", "alg": "RS256", "use": "sig"})
CLIENT_PUB = jwt.algorithms.RSAAlgorithm.from_jwk(json.dumps({k: CLIENT_JWK[k] for k in ("kty", "n", "e")}))
os.environ["OKTA_SYNC_CLIENT_ID"] = "0oaCLIENT"
os.environ["OKTA_SYNC_PRIVATE_KEY"] = json.dumps(CLIENT_JWK)
TOKEN_URL = "https://example.okta.com/oauth2/v1/token"
USERS_URL = "https://example.okta.com/api/v1/users"
ACCESS = "ACCESS-TOKEN-VALUE-123"
def thumb(jwk):
return json.dumps({k: jwk[k] for k in ("crv", "kty", "x", "y")}, sort_keys=True, separators=(",", ":"))
class StrictOkta:
def __init__(self, require_dpop=False, token_nonce=False, api_nonce=False, always_bad_proof=False,
token_type_if_plain="Bearer", pages=1, endless_nonce=False):
self.endless_nonce = endless_nonce
self.require_dpop, self.token_nonce, self.api_nonce = require_dpop, token_nonce, api_nonce
self.always_bad_proof, self.token_type_if_plain, self.pages = always_bad_proof, token_type_if_plain, pages
self.token_calls = 0
self.api_calls = 0
self.problems = [] # anything the strict checks found wrong
self.jtis = set()
self.assertion_jtis = set()
self.token_key = None # thumbprint of the key used at the token request
self.api_keys = set()
self.dpop_on_token = 0
self.dpop_on_api = 0
self.issued_nonce = "nonce-" + os.urandom(3).hex()
self.api_seen = []
def _check_proof(self, req, url, method, ath=None, need_nonce=False):
proof = req.headers.get("dpop")
if not proof:
return None, "no proof"
try:
hdr = jwt.get_unverified_header(proof)
except Exception as e: # noqa: BLE001
return None, f"unreadable header {type(e).__name__}"
if hdr.get("typ") != "dpop+jwt" or hdr.get("alg") != "ES256":
self.problems.append(f"bad header typ/alg {hdr.get('typ')} {hdr.get('alg')}")
jwk = hdr.get("jwk")
if not isinstance(jwk, dict) or "d" in jwk or jwk.get("kty") != "EC":
self.problems.append("proof jwk missing or holds private part")
return None, "bad jwk"
try:
claims = jwt.decode(proof, jwt.algorithms.ECAlgorithm.from_jwk(json.dumps(jwk)),
algorithms=["ES256"], options={"verify_iat": False})
except Exception as e: # noqa: BLE001
self.problems.append(f"signature did not verify: {type(e).__name__}")
return None, "bad signature"
if claims.get("htm") != method:
self.problems.append(f"htm {claims.get('htm')} != {method}")
if claims.get("htu") != url:
self.problems.append(f"htu {claims.get('htu')} != {url}")
if abs(time.time() - int(claims.get("iat", 0))) > 60:
self.problems.append("iat not current")
if claims.get("jti") in self.jtis or not claims.get("jti"):
self.problems.append("jti missing or reused")
self.jtis.add(claims.get("jti"))
if ath is not None and claims.get("ath") != ath:
self.problems.append("ath wrong")
if ath is None and "ath" in claims:
self.problems.append("ath present on a token request")
if need_nonce and claims.get("nonce") != self.issued_nonce:
return jwk, "nonce"
return jwk, None
def handler(self, req: httpx.Request):
if req.url.path == "/oauth2/v1/token":
self.token_calls += 1
form = {k: v[0] for k, v in parse_qs(req.content.decode()).items()}
try:
a = jwt.decode(form["client_assertion"], CLIENT_PUB, algorithms=["RS256"], audience=TOKEN_URL)
if a["jti"] in self.assertion_jtis:
self.problems.append("client assertion jti reused")
self.assertion_jtis.add(a["jti"])
except Exception as e: # noqa: BLE001
self.problems.append(f"client assertion bad: {type(e).__name__}")
has = "dpop" in req.headers
if has:
self.dpop_on_token += 1
if self.always_bad_proof:
return httpx.Response(400, json={"error": "invalid_dpop_proof"})
if self.require_dpop and not has:
return httpx.Response(400, json={"error": "invalid_dpop_proof"})
if not has:
return httpx.Response(200, json={"token_type": self.token_type_if_plain, "access_token": ACCESS})
jwk, bad = self._check_proof(req, TOKEN_URL, "POST", need_nonce=self.token_nonce)
if bad == "nonce" or (self.endless_nonce and not bad):
return httpx.Response(400, json={"error": "use_dpop_nonce"}, headers={"DPoP-Nonce": self.issued_nonce})
if bad:
return httpx.Response(400, json={"error": "invalid_dpop_proof"})
self.token_key = thumb(jwk)
return httpx.Response(200, json={"token_type": "DPoP", "access_token": ACCESS})
if req.url.path == "/api/v1/users":
self.api_calls += 1
auth = req.headers.get("authorization", "")
self.api_seen.append(auth.split(" ")[0])
if auth.startswith("DPoP "):
self.dpop_on_api += 1
if auth != f"DPoP {ACCESS}":
self.problems.append("wrong DPoP access token")
ath = base64.urlsafe_b64encode(hashlib.sha256(ACCESS.encode()).digest()).rstrip(b"=").decode()
jwk, bad = self._check_proof(req, USERS_URL, "GET", ath=ath, need_nonce=self.api_nonce)
if bad == "nonce":
return httpx.Response(401, json={"errorCode": "invalid_token"},
headers={"DPoP-Nonce": self.issued_nonce,
"WWW-Authenticate": 'DPoP error="use_dpop_nonce"'})
if bad:
return httpx.Response(401, json={})
self.api_keys.add(thumb(jwk))
if thumb(jwk) != self.token_key:
self.problems.append("API proof key differs from the token request key")
elif auth == f"Bearer {ACCESS}":
if "dpop" in req.headers:
self.problems.append("DPoP header sent with a plain Bearer token")
else:
return httpx.Response(401, json={})
page = int(req.url.params.get("after", "0") or 0)
body = [{"status": "ACTIVE", "profile": {"login": f"user{page}"}}]
headers = {}
if page + 1 < self.pages:
headers["Link"] = f'<{USERS_URL}?after={page + 1}&limit=200>; rel="next"'
return httpx.Response(200, json=body, headers=headers)
return httpx.Response(404)
def client(self):
return httpx.Client(transport=httpx.MockTransport(self.handler))
def run(fake, mode=None):
if mode is None:
os.environ.pop("OKTA_SYNC_DPOP", None)
else:
os.environ["OKTA_SYNC_DPOP"] = mode
try:
return okta_sync.fetch_users(http=fake.client()), None
except OktaSyncError as e:
return None, str(e)
# 1. auto: a plain app needs no DPoP
f = StrictOkta()
users, err = run(f)
chk("auto, app without DPoP: works with one token call, Bearer", users and f.token_calls == 1 and f.dpop_on_token == 0 and f.api_seen == ["Bearer"], str(err))
chk("no problems found by the strict checks", not f.problems, str(f.problems))
# 2. auto: the app requires DPoP (what your tenant answered)
f = StrictOkta(require_dpop=True)
users, err = run(f)
chk("auto, app requires DPoP: plain try, then DPoP try, then users", users and f.token_calls == 2 and f.dpop_on_token == 1, f"{err} calls={f.token_calls}")
chk("API calls carry DPoP and the access token", f.api_calls == 1 and f.dpop_on_api == 1 and f.api_seen == ["DPoP"])
chk("API proof used the same key as the token request", len(f.api_keys) == 1 and f.api_keys == {f.token_key})
chk("every proof and assertion id is unique, no problems", not f.problems, str(f.problems))
# 3. nonce at the token endpoint
f = StrictOkta(require_dpop=True, token_nonce=True)
users, err = run(f)
chk("token nonce: plain, DPoP without nonce, DPoP with nonce", users and f.token_calls == 3, f"{err} calls={f.token_calls}")
chk("token nonce: no problems", not f.problems, str(f.problems))
# 4. nonce at the API
f = StrictOkta(require_dpop=True, api_nonce=True)
users, err = run(f)
chk("API nonce: the call is repeated once with the nonce", users and f.api_calls == 2 and f.dpop_on_api == 2, f"{err} calls={f.api_calls}")
chk("API nonce: no problems", not f.problems, str(f.problems))
# 5. paging: a new proof for every page, htu without the query
f = StrictOkta(require_dpop=True, pages=3)
users, err = run(f)
chk("3 pages with DPoP: 3 users, 3 API calls", users and len(users) == 3 and f.api_calls == 3, f"{err} {f.api_calls}")
chk("3 pages: htu had no query, jti unique, same key", not f.problems, str(f.problems))
# 6. mode on goes straight to DPoP
f = StrictOkta(require_dpop=True)
users, err = run(f, "on")
chk("mode on: DPoP from the first token call", users and f.token_calls == 1 and f.dpop_on_token == 1, f"{err} {f.token_calls}")
f = StrictOkta()
users, err = run(f, "true")
chk("mode on with an app that does not need it: still works", users is not None and not f.problems, f"{err} {f.problems}")
# 7. mode off
f = StrictOkta(require_dpop=True)
users, err = run(f, "off")
chk("mode off, app requires DPoP: stops after one call, names the error", users is None and f.token_calls == 1 and "invalid_dpop_proof" in err, str(err))
f = StrictOkta(token_type_if_plain="DPoP")
users, err = run(f, "off")
chk("mode off, DPoP-bound token: clear refusal, users never called", users is None and "DPoP-bound" in err and f.api_calls == 0, str(err))
f = StrictOkta(token_type_if_plain="mac")
users, err = run(f)
chk("unknown token type refused", users is None and "neither" in err, str(err))
# 8. bounded retries and a hopeless server
f = StrictOkta(always_bad_proof=True)
users, err = run(f)
chk("a server that always rejects the proof: bounded calls, clear error", users is None and f.token_calls <= 4 and "invalid_dpop_proof" in err and "DPoP was used" in err, f"{err} {f.token_calls}")
chk("no users call when the token failed", f.api_calls == 0)
f = StrictOkta(require_dpop=True, token_nonce=True, endless_nonce=True)
users, err = run(f)
chk("a server that asks for a nonce forever: bounded calls, clear error", users is None and f.token_calls <= 4 and "use_dpop_nonce" in err, f"{err} {f.token_calls}")
# 9. a new key on each run
f1, f2 = StrictOkta(require_dpop=True), StrictOkta(require_dpop=True)
run(f1); run(f2)
chk("each run makes its own DPoP key", f1.token_key and f2.token_key and f1.token_key != f2.token_key)
# 10. secrets and startup line
f = StrictOkta(always_bad_proof=True)
_, err = run(f)
chk("error holds no token, key or assertion", ACCESS not in err and CLIENT_JWK["d"][:12] not in err)
line = okta_sync.describe()
chk("startup line names the DPoP mode", "DPoP auto" in line, line)
os.environ["OKTA_SYNC_DPOP"] = "on"
chk("startup line follows the setting", "DPoP on" in okta_sync.describe())
os.environ.pop("OKTA_SYNC_DPOP")
# 11. the SSWS token path is untouched
os.environ["OKTA_API_TOKEN"] = "ssws-value"
f = StrictOkta()
def ssws_handler(req):
f.api_seen.append(req.headers.get("authorization", ""))
return httpx.Response(200, json=[{"status": "ACTIVE", "profile": {"login": "a"}}])
users = okta_sync.fetch_users(http=httpx.Client(transport=httpx.MockTransport(ssws_handler)))
chk("SSWS path unchanged: SSWS header, no DPoP", f.api_seen == ["SSWS ssws-value"] and users, str(f.api_seen))
os.environ.pop("OKTA_API_TOKEN")
print("\nDONE" if fails == 0 else f"\n{fails} FAILED")
sys.exit(1 if fails else 0)

View File

@@ -0,0 +1,134 @@
#!/usr/bin/env python3
"""Does the Okta sync dry run change nothing? - D22 / T13.7.
With OKTA_SYNC_DRY_RUN on, the sync must fetch, match and apply both guards exactly
as in a live run, report who it WOULD disable, and change no account and write no
audit row. With it off (the default) behavior is as before.
Self-contained: in-memory SQLite, no server, no network, no browser.
Exit 0 all passed, 1 a failure.
"""
import logging
import os
import sys
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, ROOT)
from sqlalchemy import create_engine, select # noqa: E402
from sqlalchemy.orm import sessionmaker # noqa: E402
from sqlalchemy.pool import StaticPool # noqa: E402
from server import models, okta_sync # noqa: E402
from server.okta_sync import OktaSyncError, OktaUser, run_sync # noqa: E402
fails = 0
def chk(label, ok, extra=""):
global fails
print(("PASS " if ok else "FAIL ") + label + (f" [{extra}]" if (extra and not ok) else ""))
if not ok:
fails += 1
engine = create_engine("sqlite://", connect_args={"check_same_thread": False}, poolclass=StaticPool)
models.Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine, autoflush=False, future=True)
def seed(names):
with Session() as db:
db.query(models.AuditLog).delete()
db.query(models.User).delete()
for n in names:
db.add(models.User(id="u_" + n, username=n, is_active=True, email=""))
db.commit()
def state():
with Session() as db:
return ({u.username: u.is_active for u in db.scalars(select(models.User))},
db.query(models.AuditLog).count())
def okta(*pairs):
return lambda: [OktaUser(identity=i, status=s) for i, s in pairs]
class Capture(logging.Handler):
def __init__(self):
super().__init__()
self.lines = []
def emit(self, r):
self.lines.append(r.getMessage())
cap = Capture()
logging.getLogger("wpsuite.okta_sync").addHandler(cap)
# 1. Flag parsing
for v, want in [("", False), ("false", False), ("0", False), ("true", True), ("TRUE", True),
("1", True), ("yes", True), ("on", True), (" on ", True), ("maybe", False)]:
os.environ["OKTA_SYNC_DRY_RUN"] = v
chk(f"OKTA_SYNC_DRY_RUN={v!r} -> {want}", okta_sync.dry_run() is want)
os.environ.pop("OKTA_SYNC_DRY_RUN")
chk("unset -> live", okta_sync.dry_run() is False)
# 2. Dry run reports the plan and changes nothing
seed(["alice", "bob", "carol", "dan"])
before = state()
with Session() as db:
res = run_sync(db, fetch=okta(("alice", "ACTIVE"), ("bob", "SUSPENDED"), ("carol", "DEPROVISIONED")), dry=True)
after = state()
chk("dry run ok", res.ok and res.dry_run)
chk("dry run lists bob, carol and dan (missing)", sorted(res.disabled) == ["bob", "carol", "dan"], str(res.disabled))
chk("dry run changed no account", before == after, f"{before} {after}")
chk("dry run wrote no audit row", after[1] == 0)
chk("log says DRY RUN would disable", any("DRY RUN would disable 'bob'" in l for l in cap.lines))
chk("summary line says no account was changed and counts 3 matched, 3 would be disabled",
any("DRY RUN done, no account was changed" in l and "3 matched" in l and "3 would be disabled" in l
for l in cap.lines))
# 3. The environment decides when no argument is given
os.environ["OKTA_SYNC_DRY_RUN"] = "true"
seed(["alice", "bob"])
with Session() as db:
res = run_sync(db, fetch=okta(("alice", "ACTIVE"), ("bob", "SUSPENDED")))
chk("env on -> dry run", res.dry_run and state()[0]["bob"] is True and state()[1] == 0)
# 4. Guards still apply in a dry run
seed(["alice", "bob"])
with Session() as db:
res = run_sync(db, fetch=okta(("zed", "ACTIVE")))
chk("zero-match guard still refuses in a dry run", (not res.ok) and "probably wrong" in res.error)
def boom():
raise OktaSyncError("down")
with Session() as db:
res = run_sync(db, fetch=boom)
chk("fetch failure still fails closed in a dry run", (not res.ok) and state() == ({"alice": True, "bob": True}, 0))
# 5. Live run (flag off) is unchanged
os.environ.pop("OKTA_SYNC_DRY_RUN")
seed(["alice", "bob"])
with Session() as db:
res = run_sync(db, fetch=okta(("alice", "ACTIVE"), ("bob", "SUSPENDED")))
st = state()
chk("live run disables and logs one audit row", (not res.dry_run) and st[0]["bob"] is False and st[1] == 1)
# 6. Startup line names the mode
os.environ["OKTA_API_TOKEN"] = "tok-secret-9f3a"
os.environ["OKTA_ORG_URL"] = "https://example.okta.com"
os.environ["OKTA_SYNC_DRY_RUN"] = "true"
chk("startup line says DRY RUN", "DRY RUN" in okta_sync.describe())
os.environ.pop("OKTA_SYNC_DRY_RUN")
chk("startup line says live", "(live)" in okta_sync.describe())
chk("startup line never holds the token", "tok-secret-9f3a" not in okta_sync.describe())
print("\nDONE" if fails == 0 else f"\n{fails} FAILED")
sys.exit(1 if fails else 0)

View File

@@ -0,0 +1,218 @@
#!/usr/bin/env python3
"""Does the Okta deprovisioning sync fail closed? - D18 / T13.3.
The rule that must never be skipped or weakened: when Okta cannot be asked, or
its answer cannot be trusted, the sync changes NO account and writes NO audit
row. Treating "could not reach Okta" as "nobody is active" would lock the whole
company out on one bad afternoon.
Also checked: the sync only ever disables (it never re-enables, under any
input), writes one audit row per change with a non-human actor, leaves an
already-disabled account alone, logs only changes, and keeps temporary Okta
states (PASSWORD_EXPIRED, LOCKED_OUT, RECOVERY) from disabling anyone.
Self-contained: its own in-memory SQLite, no server, no network, no browser.
Exit 0 all passed, 1 a failure.
"""
import os
import sys
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, ROOT)
import httpx # noqa: E402
from sqlalchemy import create_engine, select # noqa: E402
from sqlalchemy.orm import sessionmaker # noqa: E402
from sqlalchemy.pool import StaticPool # noqa: E402
from server import models, okta_auth, okta_sync # noqa: E402
from server.okta_sync import OktaSyncError, OktaUser, run_sync # noqa: E402
fails = 0
def chk(label, ok, extra=""):
global fails
print(("PASS " if ok else "FAIL ") + label + (f" [{extra}]" if (extra and not ok) else ""))
if not ok:
fails += 1
engine = create_engine("sqlite://", connect_args={"check_same_thread": False}, poolclass=StaticPool)
models.Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine, autoflush=False, future=True)
def seed(rows):
"""rows: list of (username, is_active[, email]). Wipes users and audit rows first."""
with Session() as db:
db.query(models.AuditLog).delete()
db.query(models.User).delete()
for r in rows:
name, active = r[0], r[1]
db.add(models.User(id="u_" + name, username=name, is_active=active,
email=(r[2] if len(r) > 2 else "")))
db.commit()
def state():
with Session() as db:
users = {u.username: u.is_active for u in db.scalars(select(models.User))}
audits = [a.to_dict() for a in db.scalars(select(models.AuditLog))]
return users, audits
def fixed(*pairs):
return lambda: [OktaUser(identity=i, status=s) for i, s in pairs]
# ── 1. the failure rule ───────────────────────────────────────────────────────
print("\n1. FAIL CLOSED: a failed or untrusted fetch changes nothing")
BASE = [("alice", True), ("bob", True), ("carol", True)]
def boom(exc):
def f():
raise exc
return f
failing = [
("OktaSyncError (auth failure)", boom(OktaSyncError("HTTP 401"))),
("RuntimeError", boom(RuntimeError("boom"))),
("ConnectionError", boom(ConnectionError("down"))),
("TimeoutError", boom(TimeoutError("slow"))),
("ValueError", boom(ValueError("bad"))),
("KeyError", boom(KeyError("x"))),
("fetch returns an empty list", lambda: []),
("fetch returns None", lambda: None),
("fetch returns garbage (strings)", lambda: ["alice", "bob"]),
("fetch returns garbage (dicts)", lambda: [{"identity": "alice"}]),
]
for label, fetch in failing:
seed(BASE)
before = state()
with Session() as db:
res = run_sync(db, fetch=fetch)
after = state()
chk(f"{label}: ok is False", res.ok is False)
chk(f"{label}: zero accounts changed", after[0] == before[0] == {"alice": True, "bob": True, "carol": True})
chk(f"{label}: zero audit rows", after[1] == [] and res.disabled == [])
print("\n ...and through the real client, not a stand-in")
okta_auth.ISSUER = "https://example.okta.com/oauth2/default"
os.environ["OKTA_API_TOKEN"] = "tok"
for code in (401, 403, 429, 500):
seed(BASE)
c = httpx.Client(transport=httpx.MockTransport(lambda r, k=code: httpx.Response(k, json={})))
with Session() as db:
res = run_sync(db, fetch=lambda c=c: okta_sync.fetch_users(http=c))
u, a = state()
chk(f"real client, HTTP {code}: nothing changed, no audit rows",
(not res.ok) and all(u.values()) and a == [])
seed(BASE)
os.environ["OKTA_API_TOKEN"] = ""
with Session() as db:
res = run_sync(db) # fetch=None: the default path, no token set
u, a = state()
chk("default fetch with no token: nothing changed, no audit rows", (not res.ok) and all(u.values()) and a == [])
print("\n ...and when saving fails")
seed(BASE)
with Session() as db:
real_commit = db.commit
def bad_commit():
raise RuntimeError("disk full")
db.commit = bad_commit
res = run_sync(db, fetch=fixed(("alice", "ACTIVE"))) # bob and carol would be disabled
u, a = state()
chk("a failed commit keeps no change and no audit row", (not res.ok) and all(u.values()) and a == [])
print("\n ...and when no local account matches any Okta user (wrong identity attribute)")
seed(BASE)
with Session() as db:
res = run_sync(db, fetch=fixed(("zed@x.com", "ACTIVE"), ("yan@x.com", "ACTIVE")))
u, a = state()
chk("zero matches is refused, not read as 'everyone left'", (not res.ok) and all(u.values()) and a == [])
chk("...and the error says why", "identity attribute" in res.error)
# ── 2. what it does disable ───────────────────────────────────────────────────
print("\n2. a good run disables the right accounts")
seed([("alice", True), ("bob", True), ("carol", True), ("dave", True),
("erin", True), ("frank", True), ("gina", True), ("hank", True)])
okta = fixed(("alice", "ACTIVE"), ("bob", "SUSPENDED"),
# carol is MISSING from the list
("dave", "DEPROVISIONED"), ("erin", "PASSWORD_EXPIRED"),
("frank", "LOCKED_OUT"), ("gina", "RECOVERY"), ("hank", "ACTIVE"))
with Session() as db:
res = run_sync(db, fetch=okta)
users, audits = state()
chk("run is ok", res.ok, res.error)
chk("missing, SUSPENDED and DEPROVISIONED are disabled",
sorted(res.disabled) == ["bob", "carol", "dave"] and
[users[n] for n in ("bob", "carol", "dave")] == [False, False, False])
chk("ACTIVE stays active", users["alice"] is True and users["hank"] is True)
chk("PASSWORD_EXPIRED, LOCKED_OUT and RECOVERY do NOT disable (temporary states)",
users["erin"] is True and users["frank"] is True and users["gina"] is True)
chk("one audit row per disabled account", len(audits) == 3, str(len(audits)))
row = next(a for a in audits if a["summary"] == "bob")
chk("audit actor is the sync job, not a person", {a["actor"] for a in audits} == {"system:okta_sync"})
chk("audit action is user_deprovisioned_by_sync", {a["action"] for a in audits} == {"user_deprovisioned_by_sync"})
chk("audit row names the user and the Okta status found",
row["entity_type"] == "user" and row["entity_id"] == "u_bob" and row["detail"].get("okta_status") == "SUSPENDED")
chk("a missing user is recorded as MISSING",
next(a for a in audits if a["summary"] == "carol")["detail"].get("okta_status") == "MISSING")
print("\n ...run it again: only changes are logged")
with Session() as db:
res2 = run_sync(db, fetch=okta)
users2, audits2 = state()
chk("second run is ok, disables nobody", res2.ok and res2.disabled == [])
chk("second run writes no new audit rows (no duplicates)", len(audits2) == 3)
chk("accounts unchanged by the second run", users2 == users)
# ── 3. never re-enables, never touches a disabled account ─────────────────────
print("\n3. never re-enables, never touches an already-disabled account")
seed([("alice", True), ("hank", False), ("gina", False)])
with Session() as db:
res = run_sync(db, fetch=fixed(("alice", "ACTIVE"), ("hank", "ACTIVE"))) # gina missing
users, audits = state()
chk("a disabled account that is ACTIVE in Okta stays disabled", users["hank"] is False)
chk("a disabled account that is missing from Okta stays as it is", users["gina"] is False)
chk("no audit row for either (nothing changed)", audits == [] and res.disabled == [])
src = open(os.path.join(ROOT, "server", "okta_sync.py")).read()
chk("no assignment of is_active to True anywhere in okta_sync.py",
"is_active = True" not in src and "is_active=True" not in src.replace("is_active.is_(True)", ""))
# ── 4. matching ───────────────────────────────────────────────────────────────
print("\n4. matching")
seed([("ALICE", True), ("bob", True, "Bob@X.com"), ("carol", True)])
with Session() as db:
res = run_sync(db, fetch=fixed(("alice", "ACTIVE"), ("bob@x.com", "ACTIVE"), ("carol", "SUSPENDED")))
users, _ = state()
chk("username match ignores case", users["ALICE"] is True)
chk("email match works, ignoring case", users["bob"] is True)
chk("a matching SUSPENDED user is disabled", users["carol"] is False)
seed([("alice", True), ("bob", True), ("carol", True)])
with Session() as db:
run_sync(db, fetch=fixed(("alice", "ACTIVE"), ("bob", "ACTIVE"), ("bob", "SUSPENDED"),
("carol", "SUSPENDED"), ("carol", "DEPROVISIONED")))
users, _ = state()
chk("an identity listed twice, one entry active: stays active", users["bob"] is True)
chk("an identity listed twice, every entry disabling: disabled", users["carol"] is False)
# ── 5. the secret never reaches the audit row or the result ───────────────────
print("\n5. no secret in what is stored or returned")
seed(BASE)
os.environ["OKTA_API_TOKEN"] = "SECRET-TOKEN-123"
c = httpx.Client(transport=httpx.MockTransport(lambda r: httpx.Response(401, json={})))
with Session() as db:
res = run_sync(db, fetch=lambda: okta_sync.fetch_users(http=c))
chk("the failure message has no token", "SECRET-TOKEN-123" not in res.error and "example.okta.com" not in res.error)
print()
print("ALL PASSED" if not fails else f"{fails} FAILED")
sys.exit(0 if not fails else 1)

View File

@@ -0,0 +1,288 @@
#!/usr/bin/env python3
"""Does the Okta sync sign in as an OAuth service app (private_key_jwt)? - D23 / T13.9.
Checks, with a fake Okta (httpx.MockTransport) and freshly made keys:
- the token request carries the right form fields and a JWT that VERIFIES against the
public key, with iss and sub = client ID, aud = the token endpoint, kid in the header,
a short lifetime, and a one-time jti
- the users request then uses the Bearer token, not SSWS
- every failure raises OktaSyncError and the users endpoint is never called
- the key is accepted as JSON and as base64, RSA and EC; a public key is refused
- an SSWS API token still works and wins when both are set
- the key, the assertion and the token never appear in an error message or the startup line
Self-contained: no network, no server, no browser. Exit 0 all passed, 1 a failure.
"""
import base64
import json
import os
import sys
from urllib.parse import parse_qs
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, ROOT)
os.environ["DATABASE_URL"] = "sqlite://"
for v in ("OKTA_API_TOKEN", "OKTA_SYNC_CLIENT_ID", "OKTA_SYNC_PRIVATE_KEY", "OKTA_SYNC_PROFILE_ATTRIBUTE"):
os.environ.pop(v, None)
os.environ["OKTA_ORG_URL"] = "https://example.okta.com"
import httpx # noqa: E402
import jwt # noqa: E402
from cryptography.hazmat.primitives.asymmetric import ec, rsa # noqa: E402
from server import okta_sync # noqa: E402
from server.okta_sync import OktaSyncError # noqa: E402
fails = 0
def chk(label, ok, extra=""):
global fails
print(("PASS " if ok else "FAIL ") + label + (f" [{extra}]" if (extra and not ok) else ""))
if not ok:
fails += 1
def make_rsa():
pk = rsa.generate_private_key(public_exponent=65537, key_size=2048)
jwk = json.loads(jwt.algorithms.RSAAlgorithm.to_jwk(pk))
jwk.update({"kid": "rsa-kid-1", "use": "sig", "alg": "RS256"})
pub = {k: jwk[k] for k in ("kty", "n", "e")}
return jwk, jwt.algorithms.RSAAlgorithm.from_jwk(json.dumps(pub)), "RS256"
def make_ec():
pk = ec.generate_private_key(ec.SECP256R1())
jwk = json.loads(jwt.algorithms.ECAlgorithm.to_jwk(pk))
jwk.update({"kid": "ec-kid-1", "use": "sig", "alg": "ES256"})
pub = {k: jwk[k] for k in ("kty", "crv", "x", "y")}
return jwk, jwt.algorithms.ECAlgorithm.from_jwk(json.dumps(pub)), "ES256"
class FakeOkta:
def __init__(self, pub=None, alg="RS256", token_status=200, token_body=None, user_status=200):
self.pub, self.alg = pub, alg
self.token_status, self.token_body, self.user_status = token_status, token_body, user_status
self.token_calls, self.user_calls, self.seen_auth, self.form, self.verified = 0, 0, [], {}, None
def handler(self, req: httpx.Request):
if req.url.path == "/oauth2/v1/token":
self.token_calls += 1
self.form = {k: v[0] for k, v in parse_qs(req.content.decode()).items()}
if self.pub is not None and "client_assertion" in self.form:
try:
self.verified = jwt.decode(self.form["client_assertion"], self.pub, algorithms=[self.alg],
audience="https://example.okta.com/oauth2/v1/token")
except Exception as e: # noqa: BLE001
self.verified = e
body = self.token_body if self.token_body is not None else {
"token_type": "Bearer", "access_token": "ACCESS-TOKEN-VALUE", "expires_in": 3600}
return httpx.Response(self.token_status, json=body)
if req.url.path == "/api/v1/users":
self.user_calls += 1
self.seen_auth.append(req.headers.get("authorization", ""))
return httpx.Response(self.user_status, json=[
{"status": "ACTIVE", "profile": {"login": "alice"}}])
return httpx.Response(404)
def client(self):
return httpx.Client(transport=httpx.MockTransport(self.handler))
def setenv(jwk=None, as_b64=False, client_id="0oaCLIENT"):
os.environ["OKTA_SYNC_CLIENT_ID"] = client_id
if jwk is None:
os.environ.pop("OKTA_SYNC_PRIVATE_KEY", None)
else:
raw = json.dumps(jwk)
os.environ["OKTA_SYNC_PRIVATE_KEY"] = base64.b64encode(raw.encode()).decode() if as_b64 else raw
def fetch_err(fake):
try:
okta_sync.fetch_users(http=fake.client())
return None
except OktaSyncError as e:
return str(e)
# 1. Happy path, RSA, JSON form
rsa_jwk, rsa_pub, _ = make_rsa()
setenv(rsa_jwk)
chk("method is oauth", okta_sync.auth_method() == "oauth")
chk("is_configured with client id and key", okta_sync.is_configured())
f = FakeOkta(rsa_pub, "RS256")
users = okta_sync.fetch_users(http=f.client())
chk("returns the user", [u.identity for u in users] == ["alice"])
chk("token request fields", f.form.get("grant_type") == "client_credentials"
and f.form.get("scope") == "okta.users.read"
and f.form.get("client_assertion_type") == "urn:ietf:params:oauth:client-assertion-type:jwt-bearer")
v = f.verified
chk("assertion verifies against the public key", isinstance(v, dict), repr(v))
if isinstance(v, dict):
chk("iss and sub are the client id", v.get("iss") == "0oaCLIENT" and v.get("sub") == "0oaCLIENT")
chk("aud is the token endpoint", v.get("aud") == "https://example.okta.com/oauth2/v1/token")
chk("lifetime is at most 5 minutes", 0 < v["exp"] - v["iat"] <= 300)
chk("jti present", bool(v.get("jti")))
hdr = jwt.get_unverified_header(f.form["client_assertion"])
chk("kid and alg in the header", hdr.get("kid") == "rsa-kid-1" and hdr.get("alg") == "RS256")
chk("users call uses Bearer, not SSWS", f.seen_auth == ["Bearer ACCESS-TOKEN-VALUE"], str(f.seen_auth))
f2 = FakeOkta(rsa_pub)
okta_sync.fetch_users(http=f2.client())
chk("each assertion has a new jti", f.verified["jti"] != f2.verified["jti"])
# 2. base64 form and EC key
setenv(rsa_jwk, as_b64=True)
f = FakeOkta(rsa_pub)
chk("base64 form works", [u.identity for u in okta_sync.fetch_users(http=f.client())] == ["alice"])
ec_jwk, ec_pub, _ = make_ec()
setenv(ec_jwk)
f = FakeOkta(ec_pub, "ES256")
okta_sync.fetch_users(http=f.client())
chk("EC key works and verifies", isinstance(f.verified, dict), repr(f.verified))
# 3. Failures raise and never reach the users endpoint
setenv(rsa_jwk)
for label, fake in [
("token endpoint 401", FakeOkta(token_status=401, token_body={"error": "invalid_client"})),
("token endpoint 400 invalid_scope", FakeOkta(token_status=400, token_body={"error": "invalid_scope"})),
("token endpoint 500", FakeOkta(token_status=500, token_body={})),
("no access_token in body", FakeOkta(token_body={"token_type": "Bearer"})),
("DPoP token type", FakeOkta(token_body={"token_type": "DPoP", "access_token": "x"})),
("body is not an object", FakeOkta(token_body=[1, 2])),
]:
err = fetch_err(fake)
chk(f"{label}: raises, users never called", err is not None and fake.user_calls == 0, str(err))
e = fetch_err(FakeOkta(token_status=401, token_body={"error": "invalid_client"}))
chk("error carries the Okta error code and the status", "401" in e and "invalid_client" in e, e)
e = fetch_err(FakeOkta(token_status=400, token_body={"error": "<script>bad value with spaces</script>"}))
chk("an unsafe error value is dropped", "script" not in e and "400" in e, e)
# 4. Bad key material
pub_only = {k: rsa_jwk[k] for k in ("kty", "n", "e", "kid")}
for label, raw in [("public key only", json.dumps(pub_only)),
("not JSON, not base64", "{{{ not json"),
("base64 of something else", base64.b64encode(b"hello").decode()),
("wrong kty", json.dumps({"kty": "oct", "k": "AAAA"}))]:
os.environ["OKTA_SYNC_PRIVATE_KEY"] = raw
fake = FakeOkta()
err = fetch_err(fake)
chk(f"{label}: refused before any call", err is not None and fake.token_calls == 0 and fake.user_calls == 0, str(err))
if label == "public key only":
chk("public key: the message says it is a PUBLIC key", err is not None and "PUBLIC" in err, str(err))
chk(f"{label}: message holds no key text", err is not None and rsa_jwk["d"][:12] not in err and "hello" not in err)
setenv(rsa_jwk, client_id="")
os.environ["OKTA_SYNC_CLIENT_ID"] = ""
chk("no client id: not configured", okta_sync.auth_method() == "" and not okta_sync.is_configured())
os.environ["OKTA_SYNC_CLIENT_ID"] = "0oaCLIENT"
os.environ.pop("OKTA_SYNC_PRIVATE_KEY")
chk("no key: not configured", okta_sync.auth_method() == "")
# 4b. Copy and paste damage is forgiven, and the messages say which step failed
good = json.dumps(rsa_jwk)
b64 = base64.b64encode(good.encode()).decode()
variants = {
"double quotes around base64": '"' + b64 + '"',
"single quotes around base64": "'" + b64 + "'",
"line breaks every 76 characters": "\n".join(b64[i:i + 76] for i in range(0, len(b64), 76)),
"spaces and a trailing newline": " " + b64[:50] + " " + b64[50:] + " \r\n",
"padding removed": b64.rstrip("="),
"URL-safe alphabet": base64.urlsafe_b64encode(good.encode()).decode(),
"byte-order mark in the file": base64.b64encode(b"\xef\xbb\xbf" + good.encode()).decode(),
"JWK set with one key (JSON)": json.dumps({"keys": [rsa_jwk]}),
"JWK set with one key (base64)": base64.b64encode(json.dumps({"keys": [rsa_jwk]}).encode()).decode(),
}
for label, raw in variants.items():
os.environ["OKTA_SYNC_PRIVATE_KEY"] = raw
try:
f = FakeOkta(rsa_pub)
okta_sync.fetch_users(http=f.client())
chk(f"forgiven: {label}", isinstance(f.verified, dict) and f.user_calls == 1)
except OktaSyncError as e:
chk(f"forgiven: {label}", False, str(e))
# fields copied without the outer braces, and a value encoded twice, are forgiven
inner = json.dumps(rsa_jwk)[1:-1]
for label, raw in [("fields without braces (text)", inner),
("fields without braces (base64)", base64.b64encode(inner.encode()).decode()),
("encoded twice", base64.b64encode(b64.encode()).decode())]:
os.environ["OKTA_SYNC_PRIVATE_KEY"] = raw
try:
f = FakeOkta(rsa_pub)
okta_sync.fetch_users(http=f.client())
chk(f"forgiven: {label}", isinstance(f.verified, dict))
except OktaSyncError as e:
chk(f"forgiven: {label}", False, str(e))
pem = "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkq\n-----END PRIVATE KEY-----"
for label, raw in [("PEM text", pem), ("PEM in base64", base64.b64encode(pem.encode()).decode())]:
os.environ["OKTA_SYNC_PRIVATE_KEY"] = raw
err = fetch_err(FakeOkta()) or ""
chk(f"PEM is named: {label}", "PEM" in err and "MIIEvQ" not in err, err)
# the pretty-printed, hand-copied shapes that Python's strict reader refuses
def b64s(t):
return base64.b64encode(t.encode()).decode()
pretty = json.dumps(rsa_jwk, indent=2)
wrapped = pretty.replace(rsa_jwk["n"], rsa_jwk["n"][:100] + "\n" + rsa_jwk["n"][100:]) # line break inside a value
wrapped_sp = pretty.replace(rsa_jwk["d"], rsa_jwk["d"][:60] + " \r\n " + rsa_jwk["d"][60:])
curly = pretty.replace('"', "\u201c", 1)
curly = curly.replace('": ', "\u201d: ") # curly quotes after the first
trailing = pretty[:-2] + ",\n}"
for label, text in [("pretty-printed, 36 lines", pretty),
("line break inside the n value", wrapped),
("space and line break inside the d value", wrapped_sp),
("trailing comma before the closing brace", trailing)]:
for how, raw in [("base64", b64s(text)), ("plain", text)]:
os.environ["OKTA_SYNC_PRIVATE_KEY"] = raw
try:
f = FakeOkta(rsa_pub)
okta_sync.fetch_users(http=f.client())
chk(f"forgiven ({how}): {label}", isinstance(f.verified, dict))
except OktaSyncError as e:
chk(f"forgiven ({how}): {label}", False, str(e))
curly_ok = json.dumps(rsa_jwk, indent=2).replace('"kty"', "\u201ckty\u201d")
os.environ["OKTA_SYNC_PRIVATE_KEY"] = b64s(curly_ok)
try:
f = FakeOkta(rsa_pub)
okta_sync.fetch_users(http=f.client())
chk("forgiven: curly quote marks", isinstance(f.verified, dict))
except OktaSyncError as e:
chk("forgiven: curly quote marks", False, str(e))
broken = pretty.replace('"kty": "RSA",', '"kty": "RSA" "x",', 1)
os.environ["OKTA_SYNC_PRIVATE_KEY"] = b64s(broken)
err = fetch_err(FakeOkta()) or ""
chk("a real syntax error names the line and column", "line " in err and "column " in err and "starts with a brace" in err, err)
chk("the position message holds no key text", rsa_jwk["d"][:10] not in err and rsa_jwk["n"][:10] not in err, err)
os.environ["OKTA_SYNC_PRIVATE_KEY"] = json.dumps({"keys": [rsa_jwk, rsa_jwk]})
chk("a key set with two keys is refused", "more than one key" in (fetch_err(FakeOkta()) or ""))
for label, raw, want in [
("garbage characters", "!!!not*base64!!!", "not valid base64"),
("base64 of non-JSON", base64.b64encode(b"hello world").decode(), "not JSON after decoding base64 (11 characters, starts with a letter or digit;"),
("base64 of bytes that are not text", base64.b64encode(b"\xff\xfe\xfd\xfc").decode(), "not text"),
("broken JSON", "{ not json", "not JSON"),
]:
os.environ["OKTA_SYNC_PRIVATE_KEY"] = raw
err = fetch_err(FakeOkta()) or ""
chk(f"clear message: {label}", want in err, err)
chk(f"no key text in message: {label}", raw[:8] not in err.replace("OKTA_SYNC_PRIVATE_KEY", ""), err)
# 5. An SSWS token still works and wins
setenv(rsa_jwk)
os.environ["OKTA_API_TOKEN"] = "ssws-token-value"
chk("method is token when both are set", okta_sync.auth_method() == "token")
f = FakeOkta()
okta_sync.fetch_users(http=f.client())
chk("SSWS used, no token request made", f.seen_auth == ["SSWS ssws-token-value"] and f.token_calls == 0, str(f.seen_auth))
os.environ.pop("OKTA_API_TOKEN")
# 6. Secrets stay out of the startup line
setenv(rsa_jwk)
line = okta_sync.describe()
chk("startup line names the method", "OAuth service app" in line, line)
chk("startup line holds no key part", rsa_jwk["d"][:12] not in line and rsa_jwk["n"][:12] not in line)
os.environ.pop("OKTA_SYNC_CLIENT_ID"); os.environ.pop("OKTA_SYNC_PRIVATE_KEY")
chk("startup line says DISABLED with no credential", "DISABLED" in okta_sync.describe())
print("\nDONE" if fails == 0 else f"\n{fails} FAILED")
sys.exit(1 if fails else 0)

View File

@@ -0,0 +1,242 @@
#!/usr/bin/env python3
"""Does the Okta sync run on a schedule without doubling up? - D18 / T13.4.
The api container runs 2 gunicorn workers, and each starts its own timer. Checked
here: exactly one of them wins each cycle (including a race on a real file
database), a restart inside the interval does not start a second run, the
interval is configurable and cannot go below the minimum, the timer thread starts
and stops, nothing starts when the sync is not configured, and a failure inside
the scheduled path still changes nothing.
Self-contained: a throwaway SQLite file, threads, no server, no network, no browser.
Exit 0 all passed, 1 a failure.
"""
import os
import sys
import tempfile
import threading
import time
from datetime import datetime, timedelta, timezone
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, ROOT)
from sqlalchemy import create_engine, select # noqa: E402
from sqlalchemy.orm import sessionmaker # noqa: E402
from server import models, okta_auth, okta_sync # noqa: E402
from server.okta_sync import OktaSyncError, OktaUser # noqa: E402
fails = 0
def chk(label, ok, extra=""):
global fails
print(("PASS " if ok else "FAIL ") + label + (f" [{extra}]" if (extra and not ok) else ""))
if not ok:
fails += 1
tmp = tempfile.mkdtemp(prefix="oktasync_")
engine = create_engine(f"sqlite:///{os.path.join(tmp, 't.db')}",
connect_args={"check_same_thread": False, "timeout": 20}, future=True)
models.Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine, autoflush=False, future=True)
INTERVAL = 900
os.environ["OKTA_SYNC_INTERVAL_SECONDS"] = str(INTERVAL)
T0 = datetime(2026, 10, 16, 12, 0, 0, tzinfo=timezone.utc)
def wipe(users=()):
with Session() as db:
db.query(models.AuditLog).delete()
db.query(models.User).delete()
db.query(models.AppSetting).filter(models.AppSetting.key == okta_sync.CLAIM_KEY).delete()
for name, active in users:
db.add(models.User(id="u_" + name, username=name, is_active=active))
db.commit()
def users_state():
with Session() as db:
return ({u.username: u.is_active for u in db.scalars(select(models.User))},
db.query(models.AuditLog).count())
# ── 1. interval ───────────────────────────────────────────────────────────────
print("\n1. interval")
def iv(v):
if v is None:
os.environ.pop("OKTA_SYNC_INTERVAL_SECONDS", None)
else:
os.environ["OKTA_SYNC_INTERVAL_SECONDS"] = v
return okta_sync.interval_seconds()
chk("default is 900 seconds (15 minutes)", iv(None) == 900 and iv("") == 900)
chk("an env value is used", iv("600") == 600 and iv("3600") == 3600)
chk("not a number: the default", iv("soon") == 900 and iv("1.5") == 900)
chk("under the minimum is raised to 300 (a slow cycle can never overlap the next)",
iv("60") == 300 and iv("0") == 300 and iv("-5") == 300)
chk("a fetch is bounded below the minimum interval",
okta_sync.TOTAL_DEADLINE_SECONDS < okta_sync.INTERVAL_MIN_SECONDS)
iv(str(INTERVAL))
# ── 2. the claim ──────────────────────────────────────────────────────────────
print("\n2. the claim gate")
wipe()
with Session() as db:
chk("first ever claim wins (the insert is the claim)", okta_sync.claim(db, INTERVAL, now=T0) is True)
with Session() as db:
chk("a second claim in the same instant loses", okta_sync.claim(db, INTERVAL, now=T0) is False)
with Session() as db:
chk("one second before the interval is up: loses",
okta_sync.claim(db, INTERVAL, now=T0 + timedelta(seconds=INTERVAL - 1)) is False)
with Session() as db:
chk("when the interval is up: wins",
okta_sync.claim(db, INTERVAL, now=T0 + timedelta(seconds=INTERVAL)) is True)
with Session() as db:
chk("and then the next caller loses again",
okta_sync.claim(db, INTERVAL, now=T0 + timedelta(seconds=INTERVAL + 1)) is False)
# ── 3. the race ───────────────────────────────────────────────────────────────
print("\n3. exactly one of many workers wins (a real race on a file database)")
def race(n=8):
barrier = threading.Barrier(n)
wins, errors = [], []
def worker():
try:
with Session() as db:
barrier.wait()
wins.append(okta_sync.claim(db, INTERVAL, now=datetime.now(timezone.utc)))
except Exception as exc: # a lost race may surface as an error
errors.append(type(exc).__name__)
wins.append(False)
ts = [threading.Thread(target=worker) for _ in range(n)]
[t.start() for t in ts]
[t.join() for t in ts]
return sum(1 for w in wins if w), errors
wipe()
won, errs = race()
chk("no row yet, 8 workers at once: exactly 1 wins (the insert race)", won == 1, f"{won} {errs}")
bad = []
for i in range(15):
with Session() as db: # age the claim so the next race is due again
db.query(models.AppSetting).filter(models.AppSetting.key == okta_sync.CLAIM_KEY).update(
{"updated_at": datetime.now(timezone.utc) - timedelta(seconds=INTERVAL + 5)})
db.commit()
won, errs = race()
if won != 1:
bad.append((i, won, errs))
chk("row due, 8 workers at once, 15 rounds: exactly 1 wins every round", not bad, str(bad))
# ── 4. one tick ───────────────────────────────────────────────────────────────
print("\n4. a tick runs the sync once per cycle")
wipe([("alice", True), ("bob", True)])
calls = []
def fetch_ok():
calls.append(1)
return [OktaUser("alice", "ACTIVE"), OktaUser("bob", "SUSPENDED")]
r1 = okta_sync.run_if_due(Session, fetch=fetch_ok, now=T0)
chk("first tick claims and runs", r1 is not None and r1.ok and r1.disabled == ["bob"])
r2 = okta_sync.run_if_due(Session, fetch=fetch_ok, now=T0 + timedelta(seconds=30))
chk("a tick 30 seconds later does nothing (not due)", r2 is None and len(calls) == 1)
r3 = okta_sync.run_if_due(Session, fetch=fetch_ok, now=T0 + timedelta(seconds=INTERVAL))
chk("a tick when due runs again", r3 is not None and r3.ok and len(calls) == 2)
print("\n ...a restart inside the interval does not start a second run")
wipe([("alice", True), ("bob", True)])
calls.clear()
okta_sync.run_if_due(Session, fetch=fetch_ok, now=T0)
# "restart": a brand-new caller with nothing in memory, 2 minutes later
r = okta_sync.run_if_due(Session, fetch=fetch_ok, now=T0 + timedelta(seconds=120))
chk("the claim row outlives the process: no duplicate run", r is None and len(calls) == 1)
print("\n ...two workers tick in the same instant")
wipe([("alice", True), ("bob", True)])
calls.clear()
results = []
barrier = threading.Barrier(2)
def tick():
barrier.wait()
results.append(okta_sync.run_if_due(Session, fetch=fetch_ok))
ts = [threading.Thread(target=tick) for _ in range(2)]
[t.start() for t in ts]
[t.join() for t in ts]
chk("Okta is asked once, not twice", len(calls) == 1, str(len(calls)))
chk("exactly one worker got a result", sum(1 for r in results if r is not None) == 1)
_, audits = users_state()
chk("one audit row, not two", audits == 1, str(audits))
# ── 5. fail closed through the scheduled path ─────────────────────────────────
print("\n5. FAIL CLOSED through the scheduled wrapper (not just run_sync)")
for label, exc in (("OktaSyncError", OktaSyncError("HTTP 500")), ("RuntimeError", RuntimeError("x")),
("TimeoutError", TimeoutError("t"))):
wipe([("alice", True), ("bob", True)])
def failing(e=exc):
raise e
r = okta_sync.run_if_due(Session, fetch=failing, now=T0)
u, a = users_state()
chk(f"{label} in the scheduled path: ok is False, zero changes, zero audit rows",
r is not None and r.ok is False and all(u.values()) and a == 0)
wipe([("alice", True), ("bob", True)])
def broken_factory():
raise RuntimeError("database is down")
chk("the database failing at claim time: the tick ends quietly, returns None",
okta_sync.run_if_due(broken_factory, fetch=fetch_ok, now=T0) is None)
u, a = users_state()
chk("...and nothing changed", all(u.values()) and a == 0)
# ── 6. the thread ─────────────────────────────────────────────────────────────
print("\n6. the timer thread")
os.environ["OKTA_API_TOKEN"] = ""
okta_auth.ISSUER = "https://example.okta.com/oauth2/default"
chk("no token: nothing starts", okta_sync.start_scheduler(Session) is None)
chk("...no thread named okta-sync", not any(t.name == "okta-sync" for t in threading.enumerate()))
os.environ["OKTA_API_TOKEN"] = "tok"
wipe([("alice", True), ("bob", True)])
okta_sync.START_DELAY_SECONDS = 0.05
okta_sync.TICK_SECONDS = 0.05
ran = []
real_fetch = okta_sync.fetch_users
okta_sync.fetch_users = lambda http=None: (ran.append(1) or
[OktaUser("alice", "ACTIVE"), OktaUser("bob", "DEPROVISIONED")])
stop = okta_sync.start_scheduler(Session)
chk("configured: a stop Event comes back", stop is not None)
time.sleep(1.2) # about 20 ticks
u, a = users_state()
chk("the thread ran the sync on its own (bob was disabled without a manual call)", u["bob"] is False)
chk("many ticks, one run (the claim gate holds)", len(ran) == 1 and a == 1, f"ran={len(ran)} audits={a}")
th = [t for t in threading.enumerate() if t.name == "okta-sync"]
chk("one timer thread is alive", len(th) == 1 and th[0].is_alive())
chk("the thread is a daemon (never blocks shutdown)", th[0].daemon)
stop.set()
th[0].join(timeout=3)
chk("setting the stop Event ends the thread", not th[0].is_alive())
okta_sync.fetch_users = real_fetch
os.environ["OKTA_API_TOKEN"] = ""
print()
print("ALL PASSED" if not fails else f"{fails} FAILED")
sys.exit(0 if not fails else 1)

153
tests/okta_sync_ui_check.py Normal file
View File

@@ -0,0 +1,153 @@
#!/usr/bin/env python3
"""Does an auto-disable read clearly in the admin console? - D18 / T13.5.
T13.5 builds no new UI. It confirms that an account the Okta sync disabled shows
up legibly in the surface admins already use (the Activity log card on
admin.html), without special-casing, and that the disabled account is refused on
its very next request. This runs the REAL sync against a throwaway database,
then reads the real page in a headless browser at 1440px and 390px.
It does not rely on CR-019's Activity & usage card: only the Activity log card
(AuditLog) is read.
Boots its own throwaway SQLite + uvicorn + headless browser; run it alone.
Screenshots go to a folder printed at the end (WP_SHOTS_DIR overrides it).
Exit 0 all passed, 1 a failure, 2 could not run.
"""
import json
import os
import re
import sys
import tempfile
import time
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import cdp # noqa: E402
from browser_check import seed, start_server, chk, _PASS, _FAIL # noqa: E402
from qa_gate_check import api # noqa: E402
def ascii_(v, n=300):
return re.sub(r"\s+", " ", str(v)).encode("ascii", "replace").decode()[:n]
ROWS_JS = """JSON.stringify([...document.querySelectorAll('#audit-admin tbody tr')].map(
tr => [...tr.children].map(td => td.textContent.trim())))"""
def main():
exe = cdp.find_browser()
if not exe:
print("no headless-capable browser found; set WP_BROWSER.")
return 2
tmpdir = tempfile.mkdtemp(prefix="wpsuite-syncui-")
shots = os.environ.get("WP_SHOTS_DIR") or os.path.join(tmpdir, "shots")
db_path = os.path.join(tmpdir, "check.db")
server = browser = None
try:
tok = seed(db_path)
print("\n1. run the real sync against the throwaway database")
from server.db import SessionLocal
from server import okta_sync
from server.okta_sync import OktaUser
okta = lambda: [OktaUser("root", "ACTIVE"), OktaUser("sue", "ACTIVE"),
OktaUser("pat", "SUSPENDED"), OktaUser("mix", "ACTIVE"),
OktaUser("sam", "ACTIVE"), OktaUser("legacy", "ACTIVE")] # bob is missing
with SessionLocal() as db:
res = okta_sync.run_sync(db, fetch=okta)
chk("the sync disabled pat (SUSPENDED) and bob (missing)",
res.ok and sorted(res.disabled) == ["bob", "pat"], ascii_((res.ok, res.error, res.disabled)))
port = cdp.free_port()
base = "http://127.0.0.1:%d" % port
server = start_server(port, db_path)
if not server:
print("the server did not start")
return 2
print("\n2. a disabled account is refused on its very next request")
st, _ = api(base, "/api/auth/me", tok["pat"])
chk("pat (auto-disabled) is refused", st in (401, 403), st)
st, _ = api(base, "/api/auth/me", tok["bob"])
chk("bob (auto-disabled) is refused", st in (401, 403), st)
st, _ = api(base, "/api/auth/me", tok["mix"])
chk("mix (still active in Okta) still works", st == 200, st)
print("\n3. the audit rows through the API")
st, audit = api(base, "/api/audit?entity_type=user&limit=50", tok["root"])
mine = [e for e in (audit or []) if e.get("actor") == "system:okta_sync"]
chk("an admin gets both rows", st == 200 and len(mine) == 2, ascii_((st, len(mine))))
chk("each row names the action, the user, and the Okta status",
{(e["summary"], e["detail"].get("okta_status")) for e in mine} == {("pat", "SUSPENDED"), ("bob", "MISSING")},
ascii_([(e["summary"], e["detail"]) for e in mine]))
st, audit_sue = api(base, "/api/audit?entity_type=user&limit=50", tok["sue"])
chk("a project super user does not see them (they belong to no project)",
st == 200 and not [e for e in audit_sue if e.get("actor") == "system:okta_sync"])
print("\n4. the admin console, as an admin")
browser = cdp.Browser(exe)
page = browser.page()
for width, label in ((1440, "1440"), (390, "390")):
page.clear_cookies()
page.set_cookie("wp_session", tok["root"])
page.viewport(width, 900, mobile=(width < 500))
page.goto(base + "/admin.html")
time.sleep(2.0)
page.eval("void loadAudit()")
time.sleep(1.2)
rows = json.loads(page.eval(ROWS_JS) or "[]")
sync_rows = [r for r in rows if "system:okta_sync" in r]
chk("[%s] the Activity log lists both auto-disables" % label, len(sync_rows) == 2,
ascii_(rows[:4]))
if sync_rows:
r = next((x for x in sync_rows if "pat" in x), sync_rows[0])
# columns: When, Who, Action, Type, Item, Detail
chk("[%s] Who reads 'system:okta_sync', not a person" % label, r[1] == "system:okta_sync", r)
chk("[%s] Action reads 'user deprovisioned by sync'" % label,
r[2] == "user deprovisioned by sync", r)
chk("[%s] Type and Item name the account" % label, r[3] == "user" and r[4] == "pat", r)
chk("[%s] Detail gives the Okta status found" % label,
"SUSPENDED" in r[5] and "okta" in r[5].lower(), r)
miss = next((x for x in sync_rows if "bob" in x), None)
chk("[%s] a person missing from Okta reads 'MISSING'" % label,
bool(miss) and "MISSING" in miss[5], miss)
# filter + search work on it with no special-casing
page.eval("document.getElementById('audit-search').value='okta_sync'; renderAudit();")
rows = json.loads(page.eval(ROWS_JS) or "[]")
chk("[%s] searching 'okta_sync' finds exactly the sync rows" % label,
len(rows) == 2 and all("system:okta_sync" in r for r in rows), ascii_(rows))
page.eval("document.getElementById('audit-search').value='';"
"document.getElementById('audit-type').value='user'; renderAudit();")
rows = json.loads(page.eval(ROWS_JS) or "[]")
chk("[%s] the 'User accounts' filter keeps them" % label,
len([r for r in rows if "system:okta_sync" in r]) == 2)
page.eval("document.getElementById('audit-type').value=''; renderAudit();")
over = page.eval("document.documentElement.scrollWidth - document.documentElement.clientWidth")
chk("[%s] no sideways scroll on the page" % label, (over or 0) <= 0, over)
card = page.eval("(()=>{const e=document.getElementById('audit-admin');"
"e.scrollIntoView();return e.getBoundingClientRect().width>0})()")
chk("[%s] the card is on screen" % label, bool(card))
time.sleep(0.4)
page.screenshot(os.path.join(shots, "admin-activity-log-%s.png" % label), full_page=False)
errs = [e for e in page.js_errors() if "beforeunload" not in e]
chk("no JavaScript errors", not errs, ascii_(errs[:3]))
print("\n screenshots: " + shots)
finally:
if browser:
browser.close()
if server:
server.terminate()
print("\n" + "-" * 54)
print("%d/%d checks passed." % (len(_PASS), len(_PASS) + len(_FAIL)))
for f in _FAIL:
print(" - " + f)
return 1 if _FAIL else 0
if __name__ == "__main__":
sys.exit(main())

226
tests/outbox_check.py Normal file
View File

@@ -0,0 +1,226 @@
#!/usr/bin/env python3
"""Does a sign-in problem destroy queued work? - D26 / T14.1.
The outbox in html/project-data.js queues every save and sends it later. It used to
treat a 401 (the session ended) like any other 4xx: the change was marked dead and
never sent again. It also hid a full device store and sent a change under whoever
was signed in. This check drives the real page in a real browser. It replaces
window.fetch for the write endpoints only, so no real server state is needed.
1. a 401 holds the whole queue: nothing dead, no try counted, state is "held"
2. online, tab focus and the timer do not release a held queue
3. a good sign-in (wp-auth-ready) sends every change, in the original order
4. a 403 kills only that change and says why
5. a full device store is reported to the caller and the badge; nothing is dropped
6. a change is sent only under the person who made it
7. auth-guard.js never deletes the outbox
Exit 0 all passed, 1 a failure, 2 could not run.
"""
import json
import os
import re
import subprocess
import sys
import tempfile
import time
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import cdp # noqa: E402
from browser_check import seed, start_server, chk, _PASS, _FAIL # noqa: E402
KEY = "wp_sync_outbox_v1"
HERE = os.path.dirname(os.path.abspath(__file__))
HTML = os.path.join(os.path.dirname(HERE), "html")
# Replaces fetch for POST /api/wps, POST /api/sops and DELETE /api/wps/<id> only.
# window.__plan maps a work package id to a status; the default is window.__status.
STUB = """(() => {
if (!window.__realFetch) window.__realFetch = window.fetch.bind(window);
window.__calls = []; window.__status = 200; window.__plan = {};
window.fetch = function (url, opts) {
const m = ((opts && opts.method) || 'GET').toUpperCase();
const u = String(url);
if ((m === 'POST' && /\\/api\\/(wps|sops)$/.test(u)) || (m === 'DELETE' && /\\/api\\/wps\\//.test(u))) {
let id = '';
try { id = JSON.parse(opts.body).id; } catch (e) { id = decodeURIComponent(u.split('/').pop()); }
window.__calls.push(id);
const st = (id in window.__plan) ? window.__plan[id] : window.__status;
return Promise.resolve(new Response(JSON.stringify(st >= 400 ? { detail: 'stub ' + st } : { ok: true }),
{ status: st, headers: { 'Content-Type': 'application/json' } }));
}
return window.__realFetch(url, opts);
};
localStorage.removeItem('wp_sync_outbox_v1');
return true;
})()"""
def boot(page, base, tok, user="root"):
page.clear_cookies()
page.set_cookie("wp_session", tok[user])
page.goto(base + "/field.html")
for _ in range(40):
if page.eval("!!(window.WP_USER && window.ProjectData)"):
break
time.sleep(0.3)
time.sleep(0.5)
page.eval(STUB)
def queue(page):
return json.loads(page.eval("localStorage.getItem(%r) || '[]'" % KEY))
def status(page):
return page.eval("ProjectData.syncStatus()")
def push(page, ids):
page.eval("(() => { %s; return true; })()" % ";".join(
"ProjectData.pushWP({id:%r, name:%r}, 'projA')" % (i, i) for i in ids))
def main():
exe = cdp.find_browser()
if not exe:
print("no headless-capable browser found; set WP_BROWSER.")
return 2
tmpdir = tempfile.mkdtemp(prefix="wpsuite-outbox-")
db_path = os.path.join(tmpdir, "check.db")
server = None
try:
tok = seed(db_path)
port = cdp.free_port()
base = "http://127.0.0.1:%d" % port
server = start_server(port, db_path)
if server is None:
print("the test server would not start.")
return 2
print("\nThe outbox keeps every change - D26 / T14.1\nTarget: %s" % base)
browser = cdp.Browser(exe)
page = browser.page()
try:
ids = ["wp_o1", "wp_o2", "wp_o3"]
print("\n1. a 401 holds the whole queue")
boot(page, base, tok)
page.eval("window.__status = 401")
push(page, ids)
page.eval("ProjectData.flushSync()")
q = queue(page)
st = status(page)
chk("all 3 changes are still queued", [o["key"] for o in q] == ids, str([o["key"] for o in q]))
chk("none is marked dead", not any(o.get("dead") for o in q) and st["dead"] == 0)
chk("no try was counted", all((o.get("tries") or 0) == 0 for o in q), str([o.get("tries") for o in q]))
chk("the state is held", st["held"] is True, json.dumps(st))
chk("the run stopped at the first 401", len(page.eval("window.__calls")) == 1,
str(page.eval("window.__calls")))
badge = page.eval("document.getElementById('wp-sync-badge').textContent")
chk("the badge asks for a new sign-in", "Sign in again" in badge, badge)
print("\n2. only a good sign-in releases it")
page.eval("window.__status = 200")
page.eval("window.dispatchEvent(new Event('online'))")
page.eval("document.dispatchEvent(new Event('visibilitychange'))")
page.eval("ProjectData.flushSync()")
time.sleep(1.0)
chk("online, focus and a manual flush send nothing while held",
len(page.eval("window.__calls")) == 1 and len(queue(page)) == 3,
str(page.eval("window.__calls")))
print("\n3. a good sign-in sends all of them, in order")
page.eval("document.dispatchEvent(new CustomEvent('wp-auth-ready', {detail: window.WP_USER}))")
for _ in range(30):
if not queue(page):
break
time.sleep(0.3)
calls = page.eval("window.__calls")
chk("the queue is empty", queue(page) == [], str(queue(page)))
chk("the changes arrived in the original order", calls[1:] == ids or calls[-3:] == ids, str(calls))
chk("the state is no longer held", status(page)["held"] is False)
print("\n4. a 403 kills only that change, with a reason")
boot(page, base, tok)
page.eval("window.__plan = {wp_o2: 403}")
push(page, ids)
page.eval("ProjectData.flushSync()")
q = queue(page)
dead = [o for o in q if o.get("dead")]
chk("only wp_o2 is dead", [o["key"] for o in dead] == ["wp_o2"], str([o["key"] for o in q]))
chk("the others were sent", [o["key"] for o in q if not o.get("dead")] == [])
chk("the reason names the cause", dead and "no longer have access" in dead[0].get("lastErr", ""),
dead[0].get("lastErr", "") if dead else "")
chk("a 403 does not hold the queue", status(page)["held"] is False)
print("\n5. a full device store is never silent")
boot(page, base, tok)
page.eval("window.__status = 500") # keep it queued so the badge state stays visible
page.eval("""(() => {
window.__setItem = Storage.prototype.setItem;
Storage.prototype.setItem = function (k, v) {
if (k === 'wp_sync_outbox_v1') { const e = new Error('full'); e.name = 'QuotaExceededError'; throw e; }
return window.__setItem.call(this, k, v);
};
return true; })()""")
stored = page.eval("ProjectData.pushWP({id:'wp_full', name:'full'}, 'projA')")
st = status(page)
chk("the caller is told it was not stored", stored is False, repr(stored))
chk("the state says device full, 1 unsaved", st["deviceFull"] is True and st["unsaved"] == 1, json.dumps(st))
badge = page.eval("document.getElementById('wp-sync-badge').textContent")
chk("the badge says it is not saved on this device", "not saved on this device" in badge, badge)
page.eval("window.__status = 200")
page.eval("ProjectData.flushSync()")
chk("the change is still sent from memory", "wp_full" in page.eval("window.__calls"),
str(page.eval("window.__calls")))
page.eval("Storage.prototype.setItem = window.__setItem")
chk("the state clears once it is sent", status(page)["unsaved"] == 0)
print("\n6. a change is sent only under the person who made it")
boot(page, base, tok)
page.eval("window.__status = 503") # keep the change queued while we look at it
push(page, ["wp_owned"])
time.sleep(0.5)
page.eval("window.__status = 200")
q0 = queue(page)
owner = (q0[0].get("owner") if q0 else None)
chk("the change records its owner", owner == "root", repr(owner))
page.eval("window.__calls = []; window.__me = window.WP_USER; window.WP_USER = {username: 'pat'}")
page.eval("ProjectData.flushSync()")
st = status(page)
chk("person B sends nothing", page.eval("window.__calls") == [], str(page.eval("window.__calls")))
chk("the change is kept", [o["key"] for o in queue(page)] == ["wp_owned"])
chk("the badge names the owner", st["others"] == 1 and st["otherOwner"] == "root", json.dumps(st))
page.eval("window.WP_USER = window.__me")
page.eval("ProjectData.flushSync()")
chk("it is sent after the owner signs in", page.eval("window.__calls") == ["wp_owned"]
and queue(page) == [], str(page.eval("window.__calls")))
finally:
page.close()
browser.close()
print("\n7. auth-guard.js never deletes the outbox")
src = open(os.path.join(HTML, "auth-guard.js"), encoding="utf-8").read()
code = re.sub(r"/\*.*?\*/|//[^\n]*", "", src, flags=re.S)
chk("no code path touches the outbox key", KEY not in code)
chk("nothing clears all of localStorage", "localStorage.clear" not in code)
finally:
if server is not None:
server.kill()
try:
server.wait(timeout=10)
except subprocess.TimeoutExpired:
pass
try:
from server.db import engine
engine.dispose()
except Exception:
pass
print("\n%d passed, %d failed" % (len(_PASS), len(_FAIL)))
return 1 if _FAIL else 0
if __name__ == "__main__":
sys.exit(main())

View File

@@ -33,7 +33,7 @@ sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import cdp # noqa: E402
from browser_check import seed, start_server, chk, _PASS, _FAIL, _c, PW # noqa: E402
from browser_check import seed, start_server, chk, _PASS, _FAIL, _c # noqa: E402
READY = "!!document.querySelector('#pipeline-strip .pipe-cell, #pipeline-strip .pipe-empty, " \
"#pipeline-strip .pipe-error')"

270
tests/security_check.py Normal file
View File

@@ -0,0 +1,270 @@
#!/usr/bin/env python3
"""Wave 16 security checks: D19, D20, D21.
python tests/security_check.py
Self-contained, like the other probes, but needs NO browser: it builds its own
throwaway SQLite database in a temp folder, drives the API in-process with
FastAPI's TestClient, and deletes everything afterward. Your real wpsuite.db is
never touched, and no network traffic leaves the process.
Each check tests what was BROKEN, measured by the security review of
2026-10-01 (docs/reference/security-review-2026-10-01.md), not only what is
easy to assert. Every check that tests a fix FAILED against da1325c, the
commit before wave 16; the checks that say "still works" passed there too,
and are what proves the fix broke nothing.
Exit codes: 0 all passed, 1 a check failed, 2 the run could not start.
"""
import base64
import os
import shutil
import sys
import tempfile
import warnings
warnings.filterwarnings("ignore")
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
TMP = tempfile.mkdtemp(prefix="wp-security-check-")
# db.py reads DATABASE_URL at import, so the environment is set first.
os.environ["DATABASE_URL"] = "sqlite:///" + os.path.join(TMP, "security.db").replace("\\", "/")
os.environ["AUTH_SECRET_KEY"] = "security-check-key-security-check-key-0000"
os.environ.pop("WP_OKTA_FAKE_DIRECTORY", None)
sys.path.insert(0, ROOT)
try:
from fastapi.testclient import TestClient
from server import app as A, auth, models
from server.db import SessionLocal
except Exception as exc: # noqa: BLE001
print("could not start:", exc)
sys.exit(2)
RESULTS = []
def check(item, name, ok, detail=""):
RESULTS.append(bool(ok))
print(f" {'PASS' if ok else 'FAIL'} {item:<4} {name}" + (f" ({detail})" if detail and not ok else ""))
db = SessionLocal()
def account(uid, role="project_user"):
u = models.User(id=uid, username=uid[5:], role=role, email=uid[5:] + "@example.test")
db.add(u)
db.commit()
return u
def client(user=None, token=None):
c = TestClient(A.app, base_url="http://127.0.0.1", raise_server_exceptions=False)
if user is not None:
c.cookies.set(auth.COOKIE_NAME, auth.create_token(user))
if token is not None:
c.cookies.set(auth.COOKIE_NAME, token)
return c
admin = account("user_admin", "admin")
member = account("user_member") # project_user on proj_a
padmin = account("user_padmin") # project_admin on proj_a
as_admin, as_member, as_padmin = client(admin), client(member), client(padmin)
for pid in ("proj_a", "proj_b", "proj_c"):
as_admin.post("/api/projects", json={"id": pid, "name": pid})
for uid, role in (("user_member", ""), ("user_padmin", "project_admin")):
for pid in ("proj_a", "proj_b"):
db.add(models.ProjectMember(id=f"pm_{uid}_{pid}", user_id=uid, project_id=pid, role=role))
db.commit()
def b64url(raw: bytes) -> str:
return base64.urlsafe_b64encode(raw).rstrip(b"=").decode()
# ── D21: session decode fails closed ─────────────────────────────────────────
def d21():
print("\nD21 session decode fails closed")
crafted = b64url(b"[" * 1200) + "." + b64url(b"{}") + ".x"
r = client(token=crafted).get("/api/projects")
check("D21", "a crafted 1.6 KB cookie with no account gets 401, not 500",
r.status_code == 401, f"status {r.status_code}")
r = client(token="x" * 5000).get("/api/projects")
check("D21", "an over-long cookie gets 401", r.status_code == 401, f"status {r.status_code}")
no_exp = __import__("jwt").encode({"sub": member.id, "ver": 0}, auth.SECRET_KEY, algorithm="HS256")
r = client(token=no_exp).get("/api/projects")
check("D21", "a correctly signed token with no exp is refused", r.status_code == 401,
f"status {r.status_code}")
r = as_member.get("/api/auth/me")
check("D21", "a real session still works", r.status_code == 200 and r.json()["user"]["id"] == member.id,
f"status {r.status_code}")
# D18 sliding refresh must survive the stricter decode: a token near its idle
# edge, used now, comes back with a fresh cookie.
from datetime import datetime, timedelta, timezone
now = datetime.now(timezone.utc)
near = __import__("jwt").encode({"sub": member.id, "username": member.username, "role": member.role,
"ver": 0, "iat": now - timedelta(minutes=25),
"login_at": (now - timedelta(minutes=25)).timestamp(),
"exp": now + timedelta(minutes=5)}, auth.SECRET_KEY, algorithm="HS256")
r = client(token=near).get("/api/projects")
if hasattr(auth, "maybe_refresh_token"):
check("D21", "the D18 sliding refresh still reissues the session",
r.status_code == 200 and auth.COOKIE_NAME in (r.headers.get("set-cookie") or ""),
f"status {r.status_code}")
else:
# D18 (T13.1) is not on this branch (wave 16 built on main, 2026-10-06):
# there is no refresh to keep working, so prove the stricter decode still
# accepts a valid token about to expire.
check("D21", "a valid token close to its expiry is still accepted (no D18 on this branch)",
r.status_code == 200, f"status {r.status_code}")
import re
pin = re.search(r"(?im)^pyjwt==([0-9.]+)", open(os.path.join(ROOT, "server", "requirements.txt")).read())
pinned = tuple(int(x) for x in pin.group(1).split(".")) if pin else (0,)
check("D21", "server/requirements.txt pins PyJWT 2.15.1 or later", pinned >= (2, 15, 1),
pin.group(1) if pin else "no pin")
# ── D19: uploaded files download safely ──────────────────────────────────────
def d19():
print("\nD19 uploaded files download safely")
r = as_member.post("/api/wps", json={"id": "wp_files", "project_id": "proj_a", "number": "F1"})
assert r.status_code == 200, r.text
def upload(name, mime, data):
r = as_member.post("/api/wps/wp_files/files", json={
"name": name, "mime": mime, "data_base64": base64.b64encode(data).decode()})
return r.status_code, (r.json().get("file") or {}).get("id")
code, svg = upload("route.svg", "image/svg+xml",
b'<svg xmlns="http://www.w3.org/2000/svg"><script>alert(1)</script></svg>')
check("D19", "an SVG upload is still accepted (decided: accept, download only)", code == 200, f"status {code}")
r = as_member.get(f"/api/files/{svg}")
disp, csp = r.headers.get("content-disposition", ""), r.headers.get("content-security-policy", "")
check("D19", "an SVG downloads as an attachment, never inline", disp.startswith("attachment"), disp)
check("D19", "an SVG download carries a sandbox CSP", "sandbox" in csp, csp or "no CSP")
check("D19", "file responses carry nosniff", r.headers.get("x-content-type-options") == "nosniff")
for name, mime, data in (("plan.png", "image/png", b"\x89PNG\r\n\x1a\n"),
("photo.jpg", "image/jpeg", b"\xff\xd8\xff"),
("sheet.pdf", "application/pdf", b"%PDF-1.4")):
_, fid = upload(name, mime, data)
r = as_member.get(f"/api/files/{fid}")
check("D19", f"{mime} still opens inline, no sandbox",
r.status_code == 200 and r.headers.get("content-disposition", "").startswith("inline")
and "content-security-policy" not in r.headers, r.headers.get("content-disposition", ""))
check("D19", f"{mime} keeps the offline cache header",
r.headers.get("cache-control") == "private, max-age=86400", r.headers.get("cache-control", ""))
_, fid = upload("Plan é – Nivel 2.pdf", "application/pdf", b"%PDF-1.4")
r = as_member.get(f"/api/files/{fid}")
check("D19", "a drawing with a non-Latin-1 name downloads (was 500)", r.status_code == 200,
f"status {r.status_code}")
check("D19", "the real name rides in filename*",
"filename*=UTF-8''Plan%20%C3%A9" in r.headers.get("content-disposition", ""),
r.headers.get("content-disposition", ""))
_, fid = upload('a\r\nSet-Cookie: x=1;".pdf', "application/pdf", b"%PDF-1.4")
r = as_member.get(f"/api/files/{fid}")
disp = r.headers.get("content-disposition", "")
check("D19", "CR/LF and quotes in a name cannot reach the header",
r.status_code == 200 and "\r" not in disp and "\n" not in disp and "set-cookie" not in r.headers,
repr(disp))
r = client(account("user_outsider")).get(f"/api/files/{svg}")
check("D19", "a non-member still gets 403 (access check unchanged)", r.status_code == 403,
f"status {r.status_code}")
# ── D20: one SOP per project ─────────────────────────────────────────────────
def d20():
print("\nD20 one SOP per project")
from datetime import datetime, timedelta, timezone
def sop(c, **body):
body.setdefault("project_id", "proj_a")
return c.post("/api/sops", json=body)
def team(qa):
return {"sop": {"project": {"pmId": qa, "cmId": qa, "qaGroupIds": [qa]}}, "state": {}}
r = sop(as_member, name="draft", complete=False, data=team("user_padmin"))
check("D20", "a SOP posted with no id lands on sop__<project_id>",
r.status_code == 200 and r.json().get("id") == "sop__proj_a", f"{r.status_code} {r.json().get('id')}")
r = sop(as_member, id="sop__proj_a", name="done", complete=True, data=team("user_padmin"))
check("D20", "a project_user still completes the first SOP of a project", r.status_code == 200,
f"status {r.status_code}")
r = sop(as_member, id="sop_rogue", name="mine", complete=True, data=team("user_member"))
check("D20", "a project_user cannot create a second SOP (the SEC-02 attack)", r.status_code == 400,
f"status {r.status_code}")
r = sop(as_member, id="sop__proj_a", name="edit", complete=True, data=team("user_member"))
check("D20", "a project_user still cannot change the completed SOP", r.status_code == 403,
f"status {r.status_code}")
r = sop(as_member, id="sop__proj_a", name="undo", complete=False, data=team("user_member"))
check("D20", "a project_user cannot un-complete it either", r.status_code == 403, f"status {r.status_code}")
r = sop(as_padmin, id="sop__proj_a", name="revised", complete=True, data=team("user_padmin"))
check("D20", "a Project Admin can still change the completed SOP", r.status_code == 200,
f"status {r.status_code}")
qa = [u.id for u in A.project_qa_group(SessionLocal(), "proj_a")]
check("D20", "QA mail still goes to the group the real SOP names", qa == ["user_padmin"], str(qa))
# A rogue complete SOP made BEFORE D20 (written straight to the table, newer
# than the real one) must not stay the baseline.
s = SessionLocal()
old, new = datetime.now(timezone.utc) - timedelta(days=2), datetime.now(timezone.utc)
s.add(models.Sop(id="sop__proj_b", project_id="proj_b", name="real", complete=True,
data=team("user_padmin"), updated_at=old))
s.add(models.Sop(id="sop_rogue_b", project_id="proj_b", name="rogue", complete=True,
data=team("user_member"), updated_at=new))
s.commit()
r = as_member.get("/api/sops/latest?complete=true&project_id=proj_b")
check("D20", "the page-load baseline is the canonical SOP, not a newer rogue row",
r.status_code == 200 and r.json().get("id") == "sop__proj_b", f"{r.status_code} {r.json().get('id')}")
qa = [u.id for u in A.project_qa_group(SessionLocal(), "proj_b")]
team_ids = A.project_sop_team(SessionLocal(), "proj_b")
check("D20", "QA and PM/CM mail follow the canonical SOP", qa == ["user_padmin"] and team_ids == ["user_padmin", "user_padmin"],
f"qa={qa} team={team_ids}")
r = as_member.get("/api/projects/proj_b/summary")
check("D20", "the launcher summary reports the canonical SOP", r.json().get("sop_id") == "sop__proj_b",
str(r.json().get("sop_id")))
# Rows made before D20 under other ids keep working under the old rules.
s.add(models.Sop(id="sop_legacy", project_id="proj_c", name="legacy", complete=False, data={}))
db.add(models.ProjectMember(id="pm_member_c", user_id="user_member", project_id="proj_c", role=""))
db.commit(); s.commit()
r = sop(as_member, id="sop_legacy", project_id="proj_c", name="legacy edited", complete=False)
check("D20", "an existing non-canonical SOP can still be edited", r.status_code == 200,
f"status {r.status_code}")
r = sop(as_member, id="sop_legacy", project_id="proj_c", name="legacy done", complete=True)
check("D20", "...and completed the first time", r.status_code == 200, f"status {r.status_code}")
r = sop(as_member, id="sop__proj_c", project_id="proj_c", name="second", complete=True)
check("D20", "while a project has a complete SOP, another complete one needs Project Admin",
r.status_code == 403, f"status {r.status_code}")
r = sop(as_member, id="sop_legacy", project_id="proj_a", name="moved", complete=False)
check("D20", "a SOP cannot be moved into another project under a non-canonical id",
r.status_code in (400, 403), f"status {r.status_code}")
r = client(account("user_stranger")).get("/api/sops/latest?complete=true&project_id=proj_a")
check("D20", "a non-member still gets 404 for the baseline", r.status_code == 404, f"status {r.status_code}")
r = as_admin.post("/api/sops", json={"project_id": "proj_c", "name": "x", "complete": False})
check("D20", "an id-less write (smoke test, seed_demo, admin diagnostics) targets the canonical row",
r.status_code == 200 and r.json().get("id") == "sop__proj_c", f"{r.status_code} {r.json().get('id')}")
SECTIONS = [d21, d19, d20]
def main() -> int:
print("Wave 16 security checks")
try:
for section in SECTIONS:
section()
finally:
db.close()
A.engine.dispose()
shutil.rmtree(TMP, ignore_errors=True)
passed = sum(RESULTS)
print(f"\n{passed}/{len(RESULTS)} checks passed.")
return 0 if passed == len(RESULTS) else 1
if __name__ == "__main__":
sys.exit(main())

View File

@@ -0,0 +1,66 @@
#!/usr/bin/env python3
"""Is the session limit 8 hours by default? - D25 / T13.11.
The default of AUTH_SESSION_HOURS is 8. The token expiry and the cookie max-age both
follow it, a set value overrides it, and the shipped files name the same default.
Self-contained: no network, no server, no browser. Exit 0 all passed, 1 a failure.
"""
import importlib
import os
import re
import sys
from datetime import datetime, timezone
from types import SimpleNamespace
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, ROOT)
os.environ["DATABASE_URL"] = "sqlite://"
os.environ["AUTH_SECRET_KEY"] = "session-default-check-secret-0123456789abcdef"
fails = 0
def chk(label, ok, extra=""):
global fails
print(("PASS " if ok else "FAIL ") + label + (f" [{extra}]" if (extra and not ok) else ""))
if not ok:
fails += 1
def load(value):
if value is None:
os.environ.pop("AUTH_SESSION_HOURS", None)
else:
os.environ["AUTH_SESSION_HOURS"] = value
from server import auth
return importlib.reload(auth)
import jwt # noqa: E402
user = SimpleNamespace(id="u1", username="a", role="project_user", token_version=0)
auth = load(None)
chk("default is 8 hours", auth.SESSION_HOURS == 8, str(auth.SESSION_HOURS))
claims = jwt.decode(auth.create_token(user), auth.SECRET_KEY, algorithms=["HS256"])
hours = (datetime.fromtimestamp(claims["exp"], timezone.utc) - datetime.fromtimestamp(claims["iat"], timezone.utc)).total_seconds() / 3600
chk("a new token lasts 8 hours", abs(hours - 8) < 0.01, str(hours))
auth = load("2")
chk("AUTH_SESSION_HOURS=2 overrides the default", auth.SESSION_HOURS == 2)
auth = load("12")
chk("AUTH_SESSION_HOURS=12 overrides the default", auth.SESSION_HOURS == 12)
load(None)
def read(p):
return open(os.path.join(ROOT, p), encoding="utf-8").read()
chk("docker-compose.yml defaults to 8", "AUTH_SESSION_HOURS: ${AUTH_SESSION_HOURS:-8}" in read("docker-compose.yml"))
chk(".env.example says 8", re.search(r"^# AUTH_SESSION_HOURS=8$", read("server/.env.example"), re.M) is not None)
chk("DEPLOY-login-portal.md says 8", "defaults to 8" in read("DEPLOY-login-portal.md"))
for p in ("docker-compose.yml", "server/.env.example", "DEPLOY-login-portal.md", "server/auth.py"):
chk(f"no leftover default of 12 in {p}", not re.search(r"AUTH_SESSION_HOURS[^\n]{0,30}\b12\b", read(p)))
print("\nDONE" if fails == 0 else f"\n{fails} FAILED")
sys.exit(1 if fails else 0)

View File

@@ -0,0 +1,220 @@
#!/usr/bin/env python3
"""Does the offline sign-in window follow the server? - D27 / T14.2.
auth-guard.js used to let the app open offline for a fixed 12 hours after the last
good check, and every page load reset that time. The server session lasts
AUTH_SESSION_HOURS (8). This check proves the browser now uses the server's own end
time.
1. /api/auth/me returns session_expires_at and it matches the token's exp
2. the browser keeps it, and the fixed 12 hours is gone from the code
3. offline before that time: the app opens as normal
4. offline after that time: read and queue. No redirect, the mode line shows,
a new change is queued and held, not sent
5. an older cache with no end time is treated as ended (no hidden 12 hours)
6. a page load offline does not extend the cached window
7. no cache at all, offline: sign-in page
8. online with a dead session: sign-in page with next=, and the outbox is kept
9. refreshing the cached user keeps the end of the session
Exit 0 all passed, 1 a failure, 2 could not run.
"""
import base64
import calendar
import json
import os
import re
import subprocess
import sys
import tempfile
import time
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import cdp # noqa: E402
from browser_check import seed, start_server, chk, _PASS, _FAIL # noqa: E402
HERE = os.path.dirname(os.path.abspath(__file__))
HTML = os.path.join(os.path.dirname(HERE), "html")
KEY = "wp_sync_outbox_v1"
# Makes /api/auth/me fail like a missing network when localStorage.x_me_offline is set.
OFFLINE_SHIM = """(() => {
const real = window.fetch.bind(window);
window.fetch = function (u, o) {
let off = false; try { off = !!localStorage.getItem('x_me_offline'); } catch (e) {}
if (off && String(u).indexOf('/api/auth/me') !== -1) return Promise.reject(new TypeError('Failed to fetch'));
return real(u, o);
};
})();"""
STUB = """(() => {
if (!window.__realFetch) window.__realFetch = window.fetch.bind(window);
window.__calls = [];
window.fetch = function (url, opts) {
const m = ((opts && opts.method) || 'GET').toUpperCase();
if (m === 'POST' && /\\/api\\/(wps|sops)$/.test(String(url))) {
window.__calls.push(String(url));
return Promise.resolve(new Response('{}', { status: 200, headers: { 'Content-Type': 'application/json' } }));
}
return window.__realFetch(url, opts);
};
return true;
})()"""
def token_exp(token):
body = token.split(".")[1]
body += "=" * (-len(body) % 4)
return int(json.loads(base64.urlsafe_b64decode(body))["exp"])
def cache(page):
return json.loads(page.eval("localStorage.getItem('wp_auth_cache') || 'null'") or "null")
def load(page, base, path="/field.html"):
page.goto(base + path)
time.sleep(2.0)
def main():
exe = cdp.find_browser()
if not exe:
print("no headless-capable browser found; set WP_BROWSER.")
return 2
tmpdir = tempfile.mkdtemp(prefix="wpsuite-expiry-")
db_path = os.path.join(tmpdir, "check.db")
server = None
try:
tok = seed(db_path)
port = cdp.free_port()
base = "http://127.0.0.1:%d" % port
server = start_server(port, db_path)
if server is None:
print("the test server would not start.")
return 2
print("\nThe offline window follows the server - D27 / T14.2\nTarget: %s" % base)
browser = cdp.Browser(exe)
page = browser.page()
try:
page.ws.call("Page.addScriptToEvaluateOnNewDocument", {"source": OFFLINE_SHIM})
page.clear_cookies()
page.set_cookie("wp_session", tok["root"])
want = token_exp(tok["root"])
print("\n1-2. the server sends its own end time and the browser keeps it")
load(page, base)
me = page.eval("fetch('/api/auth/me').then(r => r.json())")
got = (me or {}).get("session_expires_at")
chk("/api/auth/me returns session_expires_at", bool(got), json.dumps(me)[:200])
chk("it is a UTC time that matches the token exp",
bool(got) and bool(re.match(r"^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\dZ$", got)) and
abs(calendar.timegm(time.strptime(got, "%Y-%m-%dT%H:%M:%SZ")) - want) <= 1,
"%s vs %s" % (got, want))
c = cache(page)
chk("the cache holds the server's end time",
bool(c) and abs((c.get("exp") or 0) / 1000.0 - want) <= 1, json.dumps(c)[:200])
src = open(os.path.join(HTML, "auth-guard.js"), encoding="utf-8").read()
code = re.sub(r"/\*.*?\*/|//[^\n]*", "", src, flags=re.S)
chk("the fixed 12 hours is gone from auth-guard.js", "12 * 3600" not in code and "43200000" not in code)
user = json.dumps(c["user"]) if c else "{}"
now_ms = int(time.time() * 1000)
def set_cache(obj):
page.eval("localStorage.setItem('wp_auth_cache', %s); localStorage.setItem('x_me_offline','1'); true"
% json.dumps(json.dumps(obj)))
print("\n3. offline before the end time: opens as normal")
future = now_ms + 3600 * 1000
set_cache({"user": c["user"], "exp": future, "at": 111})
load(page, base)
chk("no redirect", page.eval("location.pathname") == "/field.html", page.eval("location.href"))
chk("the user is the cached user", page.eval("window.WP_USER && window.WP_USER.username") == "root")
chk("mode is offline, not read-and-queue", page.eval("window.WP_SESSION_MODE") == "offline",
page.eval("window.WP_SESSION_MODE"))
print("\n6. a page load offline does not extend the window")
c2 = cache(page)
chk("the end time did not move", c2 and c2.get("exp") == future, json.dumps(c2))
chk("the cache was not rewritten", c2 and c2.get("at") == 111, json.dumps(c2))
print("\n4. offline after the end time: read and queue")
set_cache({"user": c["user"], "exp": now_ms - 3600 * 1000, "at": now_ms})
load(page, base)
chk("no redirect to the sign-in page", page.eval("location.pathname") == "/field.html",
page.eval("location.href"))
chk("the user is the cached user", page.eval("window.WP_USER && window.WP_USER.username") == "root")
chk("mode is read and queue", page.eval("window.WP_SESSION_MODE") == "readqueue",
page.eval("window.WP_SESSION_MODE"))
badge = page.eval("(document.getElementById('wp-sync-badge')||{}).textContent || ''")
chk("the mode line shows", "Working offline. Sign in again when you have a signal to send your changes to the project." in badge,
badge)
chk("the line sits in the live region",
page.eval("(document.getElementById('wp-sync-badge')||{getAttribute(){}}).getAttribute('role')") == "status")
page.eval(STUB)
page.eval("localStorage.removeItem(%r); ProjectData.pushWP({id:'wp_rq', name:'rq'}, 'projA'); true" % KEY)
page.eval("ProjectData.flushSync()")
time.sleep(0.5)
q = json.loads(page.eval("localStorage.getItem(%r) || '[]'" % KEY))
chk("a new change is queued", [o.get("key") for o in q] == ["wp_rq"], json.dumps(q)[:200])
chk("and held: nothing was sent", page.eval("window.__calls") == [], str(page.eval("window.__calls")))
print("\n5. an older cache with no end time counts as ended")
set_cache({"user": c["user"], "at": now_ms})
load(page, base)
chk("read and queue, no redirect, no hidden window",
page.eval("location.pathname") == "/field.html" and page.eval("window.WP_SESSION_MODE") == "readqueue",
page.eval("location.href") + " " + str(page.eval("window.WP_SESSION_MODE")))
print("\n9. refreshing the cached user keeps the end of the session")
set_cache({"user": c["user"], "exp": future, "at": 1})
page.eval("window.wpCacheAuth({username: 'renamed'}); true")
c3 = cache(page)
chk("the user changed", c3 and c3["user"].get("username") == "renamed", json.dumps(c3))
chk("the end time did not", c3 and c3.get("exp") == future, json.dumps(c3))
print("\n7. no cache, offline: the sign-in page")
page.eval("localStorage.removeItem('wp_auth_cache'); localStorage.setItem('x_me_offline','1'); true")
load(page, base)
chk("sent to login.html", page.eval("location.pathname") == "/login.html", page.eval("location.href"))
print("\n8. online with a dead session: sign-in page and the outbox is kept")
page.clear_cookies()
page.set_cookie("wp_session", tok["root"])
page.goto(base + "/field.html")
time.sleep(1.5)
page.eval("localStorage.removeItem('x_me_offline'); localStorage.setItem(%r, %s); true" % (
KEY, json.dumps(json.dumps([{"kind": "wp", "key": "wp_keep", "opId": "wp:wp_keep:1", "tries": 0,
"owner": "root", "body": {"id": "wp_keep"}}]))))
page.clear_cookies()
page.set_cookie("wp_session", "not-a-valid-token")
load(page, base)
loc = page.eval("location.pathname + location.search")
chk("online with a dead session: redirect to login.html?next=",
loc.startswith("/login.html") and "next=" in loc, loc)
q = json.loads(page.eval("localStorage.getItem(%r) || '[]'" % KEY))
chk("the queued change is still there", [o.get("key") for o in q] == ["wp_keep"], json.dumps(q)[:200])
finally:
page.close()
browser.close()
finally:
if server is not None:
server.kill()
try:
server.wait(timeout=10)
except subprocess.TimeoutExpired:
pass
try:
from server.db import engine
engine.dispose()
except Exception:
pass
print("\n%d passed, %d failed" % (len(_PASS), len(_FAIL)))
return 1 if _FAIL else 0
if __name__ == "__main__":
sys.exit(main())

236
tests/session_idle_check.py Normal file
View File

@@ -0,0 +1,236 @@
#!/usr/bin/env python3
"""Does the sliding session with a hard ceiling work? - D18 / T13.1 (checked in T13.6).
T13.1 shipped with its done-when list unchecked and no test of its own; the old
session tests had no idea about idle time. This is that test.
1. Continuous activity keeps a session alive past 30 minutes, but never past the
absolute ceiling (AUTH_SESSION_HOURS) measured from the ORIGINAL sign-in.
2. A session idle for more than 30 minutes is refused on its next request.
3. The cookie is not rewritten on every request (the refresh is throttled).
4. A token from before this shipped (no login_at) still gets a hard ceiling,
from its iat.
5. A refresh carries identity and login_at forward unchanged.
6. The two variables are documented, and both defaults are flagged as proposed.
Self-contained: throwaway SQLite, in-process test client, no network, no browser.
Exit 0 all passed, 1 a failure.
"""
import os
import re
import sys
import tempfile
from datetime import datetime, timedelta, timezone
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, ROOT)
os.environ["DATABASE_URL"] = "sqlite:///" + os.path.join(tempfile.mkdtemp(prefix="wp-idle-"), "t.db").replace("\\", "/")
os.environ["AUTH_SECRET_KEY"] = "session-idle-check-secret-not-for-production"
os.environ.pop("AUTH_IDLE_MINUTES", None)
os.environ.pop("AUTH_SESSION_HOURS", None)
import jwt # noqa: E402
from fastapi.testclient import TestClient # noqa: E402
from server import app as appmod, auth, models # noqa: E402
from server.db import Base, SessionLocal, engine # noqa: E402
if not hasattr(auth, "maybe_refresh_token"):
print("SKIP: T13.1 (sliding session) is not on this branch. It waits for T14.1.")
sys.exit(0)
fails = 0
def chk(label, ok, extra=""):
global fails
print(("PASS " if ok else "FAIL ") + label + (f" [{extra}]" if (extra and not ok) else ""))
if not ok:
fails += 1
Base.metadata.create_all(bind=engine)
with SessionLocal() as db:
db.add(models.User(id="u1", username="alice", email="a@x.test", role=auth.ROLE_ADMIN))
db.commit()
USER = db.get(models.User, "u1")
db.expunge(USER)
# A route the auth gate covers. NOT /api/auth/me: everything under /api/auth/ is
# exempt from the gate (auth._EXEMPT_PREFIXES), so no session refresh happens there
# and a probe on it would pass without testing anything.
PROBE = "/api/projects"
IDLE = auth.IDLE_MINUTES
CEIL_H = auth.SESSION_HOURS
NOW = datetime.now(timezone.utc)
def mint(login_at=None, iat=None, exp=None, **extra):
"""A token with exactly the claims given (None = leave the claim out)."""
p = {"sub": "u1", "username": "alice", "role": auth.ROLE_ADMIN, "ver": 0}
if iat is not None:
p["iat"] = iat
if login_at is not None:
p["login_at"] = login_at.timestamp()
if exp is not None:
p["exp"] = exp
p.update(extra)
return jwt.encode(p, auth.SECRET_KEY, algorithm=auth.JWT_ALG)
def raw_claims(tok):
return jwt.decode(tok, auth.SECRET_KEY, algorithms=[auth.JWT_ALG], options={"verify_exp": False, "verify_iat": False, "verify_nbf": False})
class FakeClock(datetime):
_now = NOW
@classmethod
def now(cls, tz=None):
return cls._now
real_dt = auth.datetime
def at(t):
FakeClock._now = t
auth.datetime = FakeClock
def real():
auth.datetime = real_dt
print("defaults: idle %d min, ceiling %d h" % (IDLE, CEIL_H))
# ── 1. continuous activity, then the ceiling ──────────────────────────────────
print("\n1. continuous activity stays alive past 30 minutes, but is cut off at the ceiling")
at(NOW)
tok = auth.create_token(USER)
c = raw_claims(tok)
chk("a new token carries login_at", "login_at" in c)
chk("a new token expires one idle window out, not at the ceiling",
abs(c["exp"] - (NOW + timedelta(minutes=IDLE)).timestamp()) < 2)
login_at = NOW
cur = c
alive_past_30 = False
rewrites = 0
last_exp = cur["exp"]
t = NOW
STEP = timedelta(minutes=1) # an active user: a request every minute
end = NOW + timedelta(hours=CEIL_H + 2)
cut_off_at = None
while t < end:
t += STEP
at(t)
if cur["exp"] <= t.timestamp(): # the session already lapsed
cut_off_at = t
break
if t - NOW > timedelta(minutes=IDLE):
alive_past_30 = True
new = auth.maybe_refresh_token(cur)
if new:
rewrites += 1
cur = raw_claims(new)
last_exp = cur["exp"]
real()
chk("with a request every minute the session is alive well past 30 minutes", alive_past_30)
chk("it is never extended past the ceiling (last exp <= login + %d h)" % CEIL_H,
last_exp <= (login_at + timedelta(hours=CEIL_H)).timestamp() + 1,
str(datetime.fromtimestamp(last_exp, timezone.utc)))
chk("it IS cut off once the ceiling is reached, however active the session",
cut_off_at is not None and cut_off_at <= login_at + timedelta(hours=CEIL_H) + timedelta(minutes=IDLE) + STEP,
str(cut_off_at))
chk("the claims after the last refresh still carry the ORIGINAL login_at",
abs(cur["login_at"] - login_at.timestamp()) < 1)
steps = int((CEIL_H * 60) / 1)
chk("the cookie was rewritten far less often than once per request (%d rewrites for ~%d requests)" % (rewrites, steps),
0 < rewrites < steps / 5, f"{rewrites}/{steps}")
# ── 2. idle ───────────────────────────────────────────────────────────────────
print("\n2. a session idle for more than %d minutes is refused on its next request" % IDLE)
client = TestClient(appmod.app)
idle_tok = mint(login_at=NOW - timedelta(minutes=IDLE + 1), iat=NOW - timedelta(minutes=IDLE + 1),
exp=NOW - timedelta(minutes=1))
client.cookies.set(auth.COOKIE_NAME, idle_tok)
r = client.get(PROBE)
chk("an idle session gets 401", r.status_code == 401, r.status_code)
live_tok = mint(login_at=NOW - timedelta(minutes=5), iat=NOW - timedelta(minutes=5),
exp=NOW + timedelta(minutes=IDLE - 5))
client.cookies.clear()
client.cookies.set(auth.COOKIE_NAME, live_tok)
chk("a session inside the window gets 200", client.get(PROBE).status_code == 200)
# ── 3. throttle ───────────────────────────────────────────────────────────────
print("\n3. the cookie is not rewritten on every request")
fresh = auth.create_token(USER)
client.cookies.clear()
client.cookies.set(auth.COOKIE_NAME, fresh)
cookies_set = 0
for _ in range(20):
r = client.get(PROBE)
if "set-cookie" in r.headers and auth.COOKIE_NAME in r.headers["set-cookie"]:
cookies_set += 1
chk("20 rapid requests on a fresh session: 0 cookie rewrites", cookies_set == 0, cookies_set)
aged = mint(login_at=NOW - timedelta(minutes=20), iat=NOW - timedelta(minutes=20),
exp=NOW + timedelta(minutes=2)) # 2 minutes of idle window left
client.cookies.clear()
client.cookies.set(auth.COOKIE_NAME, aged)
r = client.get(PROBE)
chk("an aged session gets a refreshed cookie on its next request",
r.status_code == 200 and auth.COOKIE_NAME in r.headers.get("set-cookie", ""))
m = re.search(auth.COOKIE_NAME + r"=([^;]+)", r.headers.get("set-cookie", ""))
newc = raw_claims(m.group(1)) if m else {}
chk("the refreshed cookie keeps the original login_at",
abs(newc.get("login_at", 0) - (NOW - timedelta(minutes=20)).timestamp()) < 1)
client.cookies.clear()
client.cookies.set(auth.COOKIE_NAME, m.group(1) if m else "")
r2 = client.get(PROBE)
chk("...and the very next request does not rewrite it again", auth.COOKIE_NAME not in r2.headers.get("set-cookie", ""))
# ── 4. tokens from before D18 ─────────────────────────────────────────────────
print("\n4. a token with no login_at still gets a hard ceiling (via iat)")
old = {"sub": "u1", "username": "alice", "role": auth.ROLE_ADMIN, "ver": 0,
"iat": (NOW - timedelta(hours=CEIL_H + 1)).timestamp(),
"exp": (NOW + timedelta(hours=3)).timestamp()} # the old flat 12 h exp, still valid
chk("past its iat-based ceiling: no refresh, the old exp is not extended", auth.maybe_refresh_token(old) is None)
young = {"sub": "u1", "username": "alice", "role": auth.ROLE_ADMIN, "ver": 0,
"iat": (NOW - timedelta(hours=1)).timestamp(),
"exp": (NOW + timedelta(minutes=2)).timestamp()}
ref = auth.maybe_refresh_token(young)
rc = raw_claims(ref) if ref else {}
chk("inside the ceiling: refreshed, and login_at is taken from iat (not 'now')",
bool(ref) and abs(rc["login_at"] - young["iat"]) < 1)
chk("the refreshed token cannot outlive iat + ceiling",
bool(ref) and rc["exp"] <= young["iat"] + CEIL_H * 3600 + 1)
nothing = {"sub": "u1", "username": "alice", "role": auth.ROLE_ADMIN, "ver": 0,
"exp": (NOW + timedelta(minutes=2)).timestamp()}
chk("no login_at and no iat: no refresh, and no crash", auth.maybe_refresh_token(nothing) is None)
junk = dict(young, login_at="not-a-number")
chk("an unparseable login_at falls back to iat, no crash", auth.maybe_refresh_token(junk) is not None)
# ── 5. identity carried forward ───────────────────────────────────────────────
print("\n5. a refresh carries the identity forward unchanged")
src = {"sub": "u9", "username": "zed", "role": "project_admin", "ver": 7,
"iat": (NOW - timedelta(minutes=20)).timestamp(),
"login_at": (NOW - timedelta(minutes=20)).timestamp(),
"exp": (NOW + timedelta(minutes=2)).timestamp()}
rc = raw_claims(auth.maybe_refresh_token(src))
chk("sub, username, role, ver are unchanged",
(rc["sub"], rc["username"], rc["role"], rc["ver"]) == ("u9", "zed", "project_admin", 7))
# ── 6. documentation ──────────────────────────────────────────────────────────
print("\n6. the two variables are documented, defaults flagged as proposed")
env = open(os.path.join(ROOT, "server", ".env.example"), encoding="utf-8").read()
dep = open(os.path.join(ROOT, "DEPLOYMENT.md"), encoding="utf-8").read()
for name in ("AUTH_IDLE_MINUTES", "AUTH_SESSION_HOURS"):
chk(f"{name} is in .env.example", name in env)
chk(f"{name} is in DEPLOYMENT.md", name in dep)
chk(".env.example calls the defaults proposed, not confirmed", re.search(r"propos", env, re.I) is not None)
chk("DEPLOYMENT.md calls the defaults proposed, not confirmed", re.search(r"propos", dep, re.I) is not None)
print()
print("ALL PASSED" if not fails else f"{fails} FAILED")
sys.exit(0 if not fails else 1)

332
tests/sync_badge_check.py Normal file
View File

@@ -0,0 +1,332 @@
#!/usr/bin/env python3
"""Does the sync badge tell the truth, work by keyboard and touch, and stay out of
the way? - D26 and BL-061 / T14.3.
1. every state shows, in words that name the PROJECT
2. Sign in and Dismiss are real <a> and <button> elements: focusable, at least
44px, with a visible focus ring. Sign in goes to login.html?next=
3. Dismiss removes only the changes the project refused
4. text contrast is 4.5:1 or better in every state
5. "Everything sent" follows real work and then hides; a page with nothing to
send shows no badge
6. the console pages (Admin, User Directory) never show it
7. at 390 and 1440 the badge covers no visible control on any page that shows it
Exit 0 all passed, 1 a failure, 2 could not run.
"""
import json
import os
import subprocess
import sys
import tempfile
import time
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import cdp # noqa: E402
from browser_check import seed, start_server, chk, _PASS, _FAIL # noqa: E402
KEY = "wp_sync_outbox_v1"
STUB = """(() => {
if (!window.__realFetch) window.__realFetch = window.fetch.bind(window);
window.__calls = []; window.__status = 200; window.__never = false;
window.fetch = function (url, opts) {
const m = ((opts && opts.method) || 'GET').toUpperCase();
const u = String(url);
if ((m === 'POST' && /\\/api\\/(wps|sops)$/.test(u)) || (m === 'DELETE' && /\\/api\\/wps\\//.test(u))) {
window.__calls.push(u);
if (window.__never) return new Promise(() => {});
const st = window.__status;
return Promise.resolve(new Response(JSON.stringify(st >= 400 ? { detail: 'The project is archived. Ask an admin to unarchive it.' } : { ok: true }),
{ status: st, headers: { 'Content-Type': 'application/json' } }));
}
return window.__realFetch(url, opts);
};
localStorage.removeItem('wp_sync_outbox_v1');
return true;
})()"""
QUOTA = """(() => {
window.__setItem = Storage.prototype.setItem;
Storage.prototype.setItem = function (k, v) {
if (k === 'wp_sync_outbox_v1') { const e = new Error('full'); e.name = 'QuotaExceededError'; throw e; }
return window.__setItem.call(this, k, v);
};
return true;
})()"""
BADGE = """(() => {
const b = document.getElementById('wp-sync-badge');
if (!b) return JSON.stringify({exists: false});
const cs = getComputedStyle(b);
return JSON.stringify({exists: true, shown: cs.display !== 'none', text: b.textContent,
role: b.getAttribute('role'), ctl: Array.from(b.querySelectorAll('.wp-sb-ctl')).map(e => e.tagName + ':' + e.textContent)});
})()"""
# Contrast of the badge text against its own background (alpha composited on the page).
CONTRAST = """(() => {
const b = document.getElementById('wp-sync-badge');
const parse = s => { const m = s.match(/rgba?\\(([^)]+)\\)/); if (!m) return null;
const p = m[1].split(',').map(x => parseFloat(x)); return {r: p[0], g: p[1], b: p[2], a: p.length > 3 ? p[3] : 1}; };
const over = (f, back) => ({r: f.r * f.a + back.r * (1 - f.a), g: f.g * f.a + back.g * (1 - f.a), b: f.b * f.a + back.b * (1 - f.a), a: 1});
const lum = c => { const f = v => { v /= 255; return v <= 0.03928 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4); };
return 0.2126 * f(c.r) + 0.7152 * f(c.g) + 0.0722 * f(c.b); };
let page = parse(getComputedStyle(document.body).backgroundColor) || {r: 255, g: 255, b: 255, a: 1};
if (page.a < 1) page = over(page, {r: 255, g: 255, b: 255});
const bg = over(parse(getComputedStyle(b).backgroundColor), page);
const fg = over(parse(getComputedStyle(b).color), bg);
const l1 = lum(fg), l2 = lum(bg);
return (Math.max(l1, l2) + 0.05) / (Math.min(l1, l2) + 0.05);
})()"""
# How many visible interactive elements the badge covers.
COVER = """(() => {
const b = document.getElementById('wp-sync-badge');
const r = b.getBoundingClientRect(); const hits = [];
document.querySelectorAll('a[href],button,input,select,textarea,summary,[role="button"],[tabindex]:not([tabindex="-1"])').forEach(o => {
if (o === b || b.contains(o)) return;
const q = o.getBoundingClientRect();
if (!q.width || !q.height || !o.getClientRects().length) return;
const cs = getComputedStyle(o); if (cs.visibility === 'hidden' || cs.display === 'none') return;
if (q.left < r.right && q.right > r.left && q.top < r.bottom && q.bottom > r.top)
hits.push((o.id || o.className || o.tagName).toString().slice(0, 30) + ' ' + (o.textContent || '').trim().slice(0, 20));
});
// Is there ANY spot on this screen where a badge this size covers nothing? Scanned on
// a finer grid than the page code uses, so "the badge missed a free spot" can fail.
const rects = [];
document.querySelectorAll('a[href],button,input,select,textarea,summary,[role="button"],[tabindex]:not([tabindex="-1"])').forEach(o => {
if (o === b || b.contains(o)) return;
const q = o.getBoundingClientRect();
if (!q.width || !q.height || !o.getClientRects().length) return;
const cs = getComputedStyle(o); if (cs.visibility === 'hidden' || cs.display === 'none') return;
rects.push(q);
});
const w = r.width, h = r.height, vw = document.documentElement.clientWidth, vh = window.innerHeight;
let free = false;
for (let y = 0; y + h <= vh && !free; y += 4) {
for (let x = 0; x + w <= vw && !free; x += 4) {
if (!rects.some(q => q.left < x + w && q.right > x && q.top < y + h && q.bottom > y)) free = true;
}
}
return JSON.stringify({hits: hits, free: free, rect: [r.left, r.top, r.right, r.bottom].map(Math.round)});
})()"""
def info(page):
return json.loads(page.eval(BADGE))
def queue(page):
return json.loads(page.eval("localStorage.getItem(%r) || '[]'" % KEY))
def boot(page, base, tok, path="/field.html", user="root", width=1440):
page.viewport(width, 844 if width < 800 else 900, mobile=width < 800)
page.clear_cookies()
page.set_cookie("wp_session", tok[user])
page.goto(base + path)
for _ in range(40):
if page.eval("!!(window.WP_USER && window.ProjectData)"):
break
time.sleep(0.3)
time.sleep(0.6)
page.eval(STUB)
def push(page, wid="wp_b1"):
page.eval("ProjectData.pushWP({id:%r, name:%r}, 'projA'); true" % (wid, wid))
time.sleep(0.7)
def drive(page, state):
"""Put the page into one badge state by using the real outbox."""
if state == "sending":
page.eval("window.__never = true")
push(page)
elif state == "retrying":
page.eval("localStorage.setItem(%r, %s); window.__status = 500; true" % (
KEY, json.dumps(json.dumps([{"kind": "wp", "key": "wp_r", "opId": "wp:wp_r:1", "tries": 3,
"owner": "root", "body": {"id": "wp_r"}}]))))
page.eval("ProjectData.flushSync()")
time.sleep(0.5)
elif state == "held":
page.eval("window.__status = 401")
push(page)
elif state == "unsaved":
page.eval(QUOTA)
page.eval("window.__never = true")
push(page)
elif state == "rejected":
page.eval("window.__status = 409")
push(page)
elif state == "readqueue":
page.eval("window.WP_SESSION_MODE = 'readqueue'; document.dispatchEvent(new CustomEvent('wp-session-mode')); true")
time.sleep(0.4)
elif state == "sent":
push(page)
time.sleep(0.3)
def main():
exe = cdp.find_browser()
if not exe:
print("no headless-capable browser found; set WP_BROWSER.")
return 2
tmpdir = tempfile.mkdtemp(prefix="wpsuite-badge-")
db_path = os.path.join(tmpdir, "check.db")
server = None
try:
tok = seed(db_path)
port = cdp.free_port()
base = "http://127.0.0.1:%d" % port
server = start_server(port, db_path)
if server is None:
print("the test server would not start.")
return 2
print("\nThe sync badge - D26 and BL-061 / T14.3\nTarget: %s" % base)
browser = cdp.Browser(exe)
page = browser.page()
try:
page.ws.call("Emulation.setFocusEmulationEnabled", {"enabled": True})
print("\n1. every state shows, in words that name the project")
expect = {
"sending": "Sending",
"retrying": "Retrying",
"held": "Sign in again",
"unsaved": "not saved on this device",
"rejected": "rejected by the project",
"readqueue": "Working offline",
}
for state, words in expect.items():
boot(page, base, tok)
drive(page, state)
b = info(page)
chk("%-9s shows: %r" % (state, words), b.get("shown") and words in b.get("text", ""), b.get("text", "")[:100])
chk("%-9s names the project" % state, "project" in b.get("text", ""), b.get("text", "")[:100])
chk("%-9s is in a polite live region" % state, b.get("role") == "status")
ratio = page.eval(CONTRAST)
chk("%-9s contrast %.1f:1 is at least 4.5:1" % (state, ratio), ratio >= 4.5, "%.2f" % ratio)
print("\n2. Sign in and Dismiss are real, focusable, 44px controls")
for state in ("held", "readqueue"):
boot(page, base, tok)
drive(page, state)
r = json.loads(page.eval("""(() => {
const a = document.querySelector('#wp-sync-badge a.wp-sb-ctl');
if (!a) return JSON.stringify({none: true});
a.focus(); const q = a.getBoundingClientRect(); const cs = getComputedStyle(a);
return JSON.stringify({tag: a.tagName, href: a.getAttribute('href'), w: q.width, h: q.height,
focused: document.activeElement === a, ring: cs.outlineStyle !== 'none' && parseFloat(cs.outlineWidth) >= 2,
pe: getComputedStyle(document.getElementById('wp-sync-badge')).pointerEvents});
})()"""))
chk("%-9s has a Sign in link" % state, r.get("tag") == "A", json.dumps(r))
chk("%-9s link goes to login.html?next=" % state,
(r.get("href") or "").startswith("login.html?next=%2F"), r.get("href"))
chk("%-9s link is at least 44px both ways" % state, r.get("w", 0) >= 44 and r.get("h", 0) >= 44,
"%sx%s" % (r.get("w"), r.get("h")))
chk("%-9s link takes focus and shows a ring" % state, r.get("focused") and r.get("ring"), json.dumps(r))
chk("%-9s the badge takes clicks (no pointer-events:none)" % state, r.get("pe") == "auto", r.get("pe"))
print("\n3. Dismiss removes only what the project refused")
boot(page, base, tok)
page.eval("window.__status = 200")
page.eval("localStorage.setItem(%r, %s); true" % (KEY, json.dumps(json.dumps([
{"kind": "wp", "key": "wp_dead", "opId": "wp:wp_dead:1", "tries": 0, "owner": "root", "dead": True,
"lastErr": "The project is archived. Ask an admin to unarchive it.", "body": {"id": "wp_dead"}},
{"kind": "wp", "key": "wp_live", "opId": "wp:wp_live:1", "tries": 0, "owner": "root", "body": {"id": "wp_live"}}]))))
page.eval("window.__never = true; ProjectData.flushSync(); true")
time.sleep(0.5)
b = info(page)
chk("the reason is shown", "archived" in b.get("text", ""), b.get("text", "")[:120])
r = json.loads(page.eval("""(() => {
const d = document.querySelector('#wp-sync-badge button.wp-sb-ctl');
if (!d) return JSON.stringify({none: true});
d.focus(); const q = d.getBoundingClientRect(); const cs = getComputedStyle(d);
return JSON.stringify({tag: d.tagName, type: d.type, w: q.width, h: q.height, focused: document.activeElement === d,
ring: cs.outlineStyle !== 'none' && parseFloat(cs.outlineWidth) >= 2});
})()"""))
chk("Dismiss is a <button type=button>", r.get("tag") == "BUTTON" and r.get("type") == "button", json.dumps(r))
chk("Dismiss is at least 44px, takes focus, shows a ring",
r.get("w", 0) >= 44 and r.get("h", 0) >= 44 and r.get("focused") and r.get("ring"), json.dumps(r))
page.eval("document.querySelector('#wp-sync-badge button.wp-sb-ctl').click(); true")
time.sleep(0.4)
keys = [o["key"] for o in queue(page)]
chk("the refused change is gone", "wp_dead" not in keys, str(keys))
chk("the waiting change is kept", "wp_live" in keys, str(keys))
print("\n5. 'Everything sent' follows real work, then hides")
boot(page, base, tok)
time.sleep(2.5)
chk("a page with nothing to send shows no badge", not info(page).get("shown"))
drive(page, "sent")
seen = False
for _ in range(10):
if "Everything sent to the project" in info(page).get("text", "") and info(page).get("shown"):
seen = True
break
time.sleep(0.2)
chk("after real work it says everything was sent to the project", seen, info(page).get("text", ""))
time.sleep(2.6)
chk("and then hides", not info(page).get("shown"))
page.eval("ProjectData.flushSync(); true")
time.sleep(0.6)
chk("an idle flush does not flash it again", not info(page).get("shown"))
print("\n6. the console pages never show it")
for path in ("/admin.html", "/users.html"):
boot(page, base, tok, path)
has = page.eval("document.body.hasAttribute('data-wp-no-sync-badge')")
page.eval("window.__status = 401")
push(page, "wp_console")
b = info(page)
chk("%s opts out" % path, has is True)
chk("%s shows no badge even with a held queue" % path, not b.get("shown"), b.get("text", "")[:80])
print("\n7. the badge covers no control, at 390 and 1440")
pages = [("/field.html", "field"),
("/index.html", "launcher"),
("/work-package-suite.html?project=projA", "wizard"),
("/wp-creation-index.html?project=projA&wp=wpA1", "creator")]
for width in (390, 1440):
for path, label in pages:
for state in ("sending", "held", "rejected", "unsaved", "readqueue"):
boot(page, base, tok, path, width=width)
drive(page, state)
b = info(page)
if not b.get("shown"):
chk("%4d %-8s %-9s badge shows" % (width, label, state), False, "hidden")
continue
cov = json.loads(page.eval(COVER))
r = cov["rect"]
inside = r[0] >= 0 and r[2] <= width + 1
# The rule: the badge covers no control whenever the screen has
# room for it. A screen with no free gap of that size (BL-072)
# cannot satisfy it, and is reported as such, not hidden.
ok = (not cov["hits"]) or (not cov["free"])
note = "" if not cov["hits"] else " (no free gap on this screen, BL-072)"
chk("%4d %-8s %-9s covers no control, fits the screen%s" % (width, label, state, note),
ok and inside, "%s rect=%s free=%s" % (cov["hits"][:2], r, cov["free"]))
finally:
page.close()
browser.close()
finally:
if server is not None:
server.kill()
try:
server.wait(timeout=10)
except subprocess.TimeoutExpired:
pass
try:
from server.db import engine
engine.dispose()
except Exception:
pass
print("\n%d passed, %d failed" % (len(_PASS), len(_FAIL)))
return 1 if _FAIL else 0
if __name__ == "__main__":
sys.exit(main())

View File

@@ -47,7 +47,7 @@ sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import cdp # noqa: E402
from browser_check import seed, start_server, PW # noqa: E402,F401
from browser_check import seed, start_server # noqa: E402
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
HTML = os.path.join(ROOT, "html")

View File

@@ -7,7 +7,13 @@ the suite, so no work package had an address. This checks the promise those emai
will rest on.
1. a URL identifying a work package opens that work package
2. the same URL works for a SIGNED-OUT user, via login, landing on the target
2. the same URL works for a SIGNED-OUT user, via the real Okta sign-in round
trip (T10.7's fake provider stands in for Okta itself — see
server/okta_fake.py — but the app's own login.html, the redirect to
/api/auth/okta/login, the state round trip through SessionMiddleware, and
okta_callback()'s handling of ?next= are all real, unmodified code).
Landing on the requested target, not the home page, doubles as setup for
scenarios 3-6 below.
3. refresh preserves project, package, tab and view
4. Back and Forward move through states without a reload or a broken view
5. the URL survives being copied to a second browsing context
@@ -27,7 +33,7 @@ sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import cdp # noqa: E402
from browser_check import seed, start_server, chk, _PASS, _FAIL, _c, PW # noqa: E402
from browser_check import seed, start_server, chk, _PASS, _FAIL, _c # noqa: E402
def settle(page, seconds=1.4):
@@ -168,7 +174,7 @@ def main():
finally:
page2.close()
print("\n2. the same URL works for a signed-out user, via login")
print("\n2. the same URL works for a signed-out user, via the real Okta round trip")
page.clear_cookies()
page.goto(deep)
settle(page, 1.6)
@@ -177,19 +183,44 @@ def main():
nxt = page.eval("new URLSearchParams(location.search).get('next')||''")
chk("...carrying the requested target, package id and all",
"wp-creation-index.html" in nxt and "wp=wpA1" in nxt, "next=%r" % nxt)
page.eval("document.getElementById('username').value=%r" % "root")
page.eval("document.getElementById('password').value=%r" % PW)
page.eval("document.querySelector('form').requestSubmit"
"? document.querySelector('form').requestSubmit()"
": document.querySelector('form').submit()")
for _ in range(40):
if "wp-creation-index.html" in page.eval("location.href"):
# Drive the actual button, not a shortcut to it — its href already
# carries ?next= (login.js's safeNext()); this is the same click a
# person makes.
signin_href = page.eval(
"(document.getElementById('okta-signin')||{}).getAttribute('href')||''")
chk("the sign-in link itself carries ?next=", "next=" in signin_href, signin_href)
page.goto(base + signin_href)
for _ in range(30):
if "_fake_provider" in page.eval("location.href"):
break
time.sleep(0.3)
settle(page, 1.2)
chk("the app hands off to the (fake) Okta provider",
"_fake_provider" in page.eval("location.href"), page.eval("location.href"))
# The fake provider's own picker page — a real page, not a shortcut.
# See server/okta_fake.py: only the network-touching Authlib calls are
# faked, not app.py's own login/callback/JIT/guard code.
identity_href = page.eval(
"(document.getElementById('okta-fake-identity-root')||{}).getAttribute('href')||''")
chk("the fake provider offers the seeded 'root' identity", bool(identity_href),
page.eval("document.body.innerHTML"))
page.goto(base + identity_href)
for _ in range(30):
href = page.eval("location.href")
if "login.html" not in href and "_fake_provider" not in href:
break
time.sleep(0.3)
settle(page, 1.0)
# NOT `"wp-creation-index.html" in location.href` alone — that string
# is in the ?next= parameter too, so this would pass while still
# sitting on login.html with the sign-in rejected (the same mistake
# D13/T10.7's LDAP predecessor caught and fixed here). Assert we
# actually LEFT the login page.
href = page.eval("location.href")
chk("signing in continues to the requested page, not the home page",
"wp-creation-index.html" in page.eval("location.href"),
page.eval("location.href"))
"login.html" not in href and "wp-creation-index.html" in href
and "wp=wpA1" in href, href)
for _ in range(30):
if page.eval("!!window.wpCreatorReady"):
break

Some files were not shown because too many files have changed in this diff Show More