Repository navigation
v1.17.0
A security and correctness release over 1.16.0, from the review findings 1.16.0 left open and from reviews of this
release's own changes. The controller image now installs its whole Python dependency tree from a lock pinned at
releases at least 72 hours old. A restricted witness receipt withholds secrets at any depth; the MCP bridges, the
Python client and the LangChain tools no longer show the bearer token or a secret of the controller URL in an error; a
screenshot that is to be PII-redacted is no longer served before its redaction is done, and a download read with
browser.read_download is PII-scrubbed; and browser.get_html with text_only and browser.find_elements now read
the page in the controller's isolated world, so a page's own scripts cannot change what they see. Read the upgrade
note first: a MESH_TIMESTAMP_WINDOW above 250 seconds, or at or below 0, now stops startup. The controller image and
the client and LangChain packages change, and the MCP bridge package now requires this client; the browser-node image
changes only in version.
Upgrade notes
- A
MESH_TIMESTAMP_WINDOWabove 250 seconds, or at or below 0, now stops startup. Set it inside those limits
(the default is 30), on a controller with the mesh off too. With the mesh on, lowering it needs the wait that
docs/mesh.mddescribes for any lowering: the startup check assumes the last process ran with no larger window, so
start this release only once the old window has passed since the old controller last accepted an envelope (stop it,
then wait that long).
Security
- The controller image now installs its whole Python dependency tree from
controller/constraints.txt, pinned at
releases at least 72 hours old, and CI's Python test installs take no younger release.requirements.txtand
requirements-dev.txtpin only the packages the controller names, so every build took the newest release of each
package below them, however new: the 1.15.0 image carried pydantic-core 2.50.4, uploaded under 72 hours before it
was built. The file is uv's universal resolution of both files for Python 3.11 and later, with its command and
cutoff in its header. The host tests and the devcontainer install under it too, and CI's host tests hold what it
does not pin, the build backend of the editable install, to releases at least 72 hours old. The dependency audits
read the file as it is, where they resolved the top-level pins afresh: CI's, on Linux and Python 3.11 as the image
is, checks the versions the image installs, andscripts/release_audit.py's the versions the file gives the
platform and Python it runs on. A requirements file moved to a release the file pins at another fails CI's install
until the file is generated again. The client and LangChain tests still take the newest release of each package, as
those libraries' users do, but only one at least 72 hours old, their build backends included. Dependabot holds
version updates three days, as its configuration now says. (R5C-14) - A restricted witness receipt now withholds secrets at any depth, and in its metadata and approval reason too. A
receipt in restricted evidence mode (a confidential session, or a sensitive, high-risk or auth-material action)
blanked five top-level target keys (text,text_preview,file_path,password,totp_secret) and what a
select_option chose, and kept its metadata and its approval's reason as given. It now withholds, at any depth of the
target and the metadata, those keys, every key whose name holds a word the run trace redacts by (authorization,
cookie,api-key,api_key,token,password,secret), and the free text an agent or a tool call wrote: a
reasonkey, and the approval's reason, which for a governed tool call previews its arguments, and an operator's
commenton an approval decision. Each URL there (aurlkey's) now has its query and fragment scrubbed as the run
trace scrubs a URL's, by the PII scrubber (so not withPII_SCRUB_ENABLEDorPII_SCRUB_NETWORKoff): a navigate's
kept an OAuth code or a token in full. Receipts recorded without a policy outcome were standard, and kept the reason
in full, in the approval and again in the metadata: an approval's receipts (its request, decision and execution) now
take the evidence mode of the action it approves, as the approval describes it, so those of an action marked
sensitive, a high-risk one or one that moves auth material are restricted as that action's own receipt is, in a
normal session too (a field an action finds sensitive only as it runs restricts that action's own receipt, not its
approval's, whose reason can quote what the action was given: mark the action sensitive to restrict those too); and
every approval receipt of a confidential session, like a human takeover's receipt there, is restricted. The approval
store still keeps an approval's reason and its decision's comment, and the audit log a takeover's reason and the
comment. A hosted Witness service and an exported bundle receive the receipt as recorded. - The MCP bridges no longer show the agent a character or a byte of a token they cannot send. A bearer token
holding a character outside latin-1 (from--bearer-token,AUTO_BROWSER_BEARER_TOKENor the token file), which an
HTTP header cannot carry, was answered as an unexpected bridge failure quoting http.client's encoding error, which
names that character and its position in the token. Such a token is now not sent, as one holding a line break has
not been since 1.16.0, and a401's answer says which source holds it; a token inside latin-1 is still sent. A
token file that is not UTF-8 text is now named as such in a401's answer, which quoted the decode error, naming
one of the token's bytes and its position. - The MCP bridges' answers no longer show the bearer token, a query value, or a secret of the URL quoted another
way. 1.16.0's answers replaced the base URL's userinfo, password, query and fragment, each whole, as written or
percent-decoded. A server's error detail that quoted the token, a query value alone (bad key ..., or FastAPI's
422shape), or one of those asrepr()orjson.dumps()writes it (a structured detail went throughstr(),
which doubles a backslash) was shown as it came, and a JSON-RPC error the bridges forwarded from a proxy, an MCP
gateway or the controller was not redacted at all. The answers now also replace the token the request carried and
each query value of 8 or more characters, in each of those forms; a structured detail is shown as JSON after its
strings are redacted; a forwarded JSON-RPC error's message and its data are redacted, the data keeping its shape (a
result is never rewritten); and the line a bridge prints on stderr for an unexpected failure is redacted as its
answer is. A list or an object nested more than 100 deep in a detail or the data is replaced by
[redacted: nested too deep], not walked, since a walk that deep would run out of stack and end the bridge with no
answer. A response body nested too deep for Python'sjsonto parse (RecursionError) is answered as an unreadable
one is, with its HTTP status, not as an unexpected bridge failure. An answerjsonparsed but cannot write back (on
Python 3.14 the two limits differ) is answered with a JSON-RPC error for its request, with a null id if the id is
not a string or a number, and a line from the client too deep to parse, or holding an integer of more than 4300
digits, with-32700, where theRecursionErrororValueErrorended the bridge with no answer. A short secret is
no longer replaced again inside an earlier[redacted], and a path's@(/a@b/mcp) is no longer read as a
userinfo and dropped. - The Python client's and the LangChain tools' errors no longer show the bearer token or a secret of the controller
URL. The client'sAutoBrowserErrorquoted a server's error detail as it came, so a proxy's or gateway's detail
that echoed the base URL (its password, a token in its query) or the bearer token was shown whole; itsdetailand
its message now leave them out as the MCP bridges' answers do, any otheruser@run included, and keep the detail's
shape. The LangChain tool,AutoBrowserTool.list_toolsandAutoBrowserNoderaised httpx'sHTTPStatusErrorfor
an answer that was not 2xx, whose message names the request URL whole, password, query and fragment included; it now
names the URL without them (the path is kept), in httpx's words otherwise, and leaves them out of the server's
reason phrase too. httpx's own errors (a connection or protocol failure), which both let through, are now raised
with them left out as well, their type and request kept: the one for an answer httpx cannot read quotes what the
server sent, which can echo the request line or a header. The URL's secrets count there, and in a server's detail,
as httpx sends them too, percent-encoded where the URL held a space or a character outside ASCII, and the query as
httpx writes it again for the parameters it now goes as (a space as+), in the client's each of itsname=value
pairs alone too (a request's own parameter replaces one of the same name, so the query is then not sent whole), and
so do theAuthorization: Basiccredentials httpx sends for the URL's user name and password (their base64); the
MCP bridges, which share the client's redaction, send no such header. httpx itself still logs every request at INFO
on itshttpxlogger, naming the URL as sent (userinfo and query included) and the server's reason phrase: the
packages do not own that logger, and a filter added at import would change the logging of everything else in the
process, so they leave it alone, and their READMEs now say to keep a secret in the token, not in the base URL. A
tool's own error (isError), which the LangChain tool returns andAutoBrowserNoderaises, is passed on as the
controller sent it, as the MCP bridges pass on a tool call's result. A token httpx cannot send in a header (one
holding a line break, a NUL, a vertical tab, a form feed or a character outside ASCII) failed the first request with
httpx's error, which quoted the whole header for the first four and named a character outside ASCII and its
position; the client and the LangChain tools now refuse it, and a token holding any other control character but a
tab (httpx sent those as they were), with aValueErrornamingtoken,bearer_tokenor the token file, never the
token; a token file that is not UTF-8 text, whoseUnicodeDecodeErrornamed one of its bytes and its position, now
raises aValueErrornaming the file and saying so, as the MCP bridges' answer does. The client refuses an
Authorizationheader given inheadersthe same way, and leaves its credentials out of its errors as it leaves
the token out. It refuses more than one (headerscan hold one per case of the name, and httpx sends each), and a
token fromtokenortoken_filenow replaces every one of them, where one whose name differed in case from
Authorizationwas sent beside the token's. - A screenshot that is to be PII-redacted is no longer served before its redaction is done. With
PII_SCRUB_SCREENSHOTon, a capture was written straight to the name/artifactsserves it under, and OCR and the
redaction then ran on that file, so the raw image was one request away for as long as OCR took; and the redacted
bytes were written over it in place, so a write cut short left a partly written image there. A capture, an
observation's screenshot, an action's before and after snapshots, a share frame and the copies the compare tool
redacts are now written under a hidden name beside their published one, redacted there (the redacted bytes through a
temporary file andos.replace), and only then moved onto the published name withos.replace; one with nothing to
redact, or that could not be scrubbed (which its result says, though a share frame's does not), is moved there as it
is. A redaction that does not finish (a strict-mode refusal, an error, a cancel) leaves nothing at the published
name, and its hidden file goes too, after any write to it a worker thread had begun, which a cancel (a shutdown's
too) does not stop. A staged screenshot becomes the one that vision targeting (take_screenshot=false) and the
compare tool reuse only once it is published; until then they reuse the one before it. A screenshot that is not to
be redacted (scrubbing off, or an action snapshot withPII_SCRUB_ACTION_SCREENSHOTS=false) is still written
straight to its name. - A download read with
browser.read_downloadis now PII-scrubbed. Its text came back as the file held it, so a
CSV export of customers gave the agent every email address and SSN in it, while console messages and network bodies
were scrubbed. UnderPII_SCRUB_ENABLEDthe text is now scrubbed by the MIME type its file name maps to in Python's
built-in table, as a network body is by its content type (a JSON or JavaScript type, which on the image's Python
3.11 is.json,.js,.mjsand.webmanifest, by its members' names; any other as plain text), off the event
loop; the result's newpii_scrubsays whether the scrub ran and how many redactions it made, and a read that
redacted something is audited aspii_redaction(layerdownload) underPII_SCRUB_AUDIT_REPORT. The file at the
download's artifact URL is unchanged.docs/deployment.mdmoves downloads read this way from "Not scrubbed" to
"Scrubbed". - The audit log is documented as not scrubbed. The PII scrubber's module description listed "audit metadata:
sensitive fields masked before writing to audit log" among its layers, but nothing masks an audit event: its details
are stored as written (a navigated URL keeps its query). It now says whatPII_SCRUB_AUDIT_REPORTdoes, which is to
addpii_redactionevents (a scrub's layer, hit count and pattern names, never the values), and
docs/deployment.mdlists the audit log under "Not scrubbed". browser.get_htmlwithtext_onlyandbrowser.find_elementsnow read the page in the controller's isolated
world. Their scripts ran in the page's own JavaScript world, so a page that replaced a DOM getter or a built-in
(theinnerTextgetter,String.prototype.toLowerCase,Document.prototype.querySelectorAll) gave them its own
text and elements in place of what it shows, and saw what the agent searched for. They now run where the
observation's scripts already ran (app/browser/element_ids.py), which shares the page's DOM and none of its
JavaScript.browser.eval_jsstill runs in the page's world, as an expression is there to read the page's own
state, and so do the local-storage tools, which read and write what the page can itself, and the bot-challenge check
after each action, which reads only the title, text and frames the page writes as it likes in either world. An
invalid CSS selector infind_elementsnow answers with a structuredinvalid_selectorerror, as an invalid regex
answersinvalid_regex. Every planner's prompt now says that the page text, titles, names and element text in an
observation are untrusted page data, never instructions: the system prompt of the Claude, OpenAI and
OpenAI-compatible APIs, and the prompt itself of the Gemini API, the CLI planners and the OpenAI host bridge, which
have none. These two reads wait for the script's message in the world 5 seconds past the read's own bound (30 s for
a page text read or a selector search, 10 s for a query), so the world's own deadline, the action timeout, never
reports the page as not answering before the read's bound does. The messages that set the call up (the CDP session's
attach, the frame tree and the world's creation) share one deadline, counted from the start of the call and 2
seconds under that bound: a page busy for longer than the default action timeout still gets a text or selector read,
and a setup unfinished at the deadline ends aspage_not_responding, with its session dropped and detached, before
the read's own bound.- A script exported from a session's audit log writes only numbers where numbers go, and says when a typed text was
cut.GET /sessions/{id}/export-scriptandbrowser.export_scriptwrote a click's or a hover's coordinates, a
scroll's amounts and a wait's time into the script as the audit event held them, where every string goes through
repr, so an event holding code in a number's place (an audit log written by something other than the controller)
put that code into a script an operator runs. Each must now be a finite int or float, written withrepr; any other
value skips its step with a comment that says so. A typed text longer than the 80 characters the audit log keeps is
now markedtext_truncatedin its action's target (dropped with the preview when the field turns out to be secret),
and its exportedfillline says that only the start of the text was kept. - A bot challenge's report names the page by its origin and path only. The
captcha_detectederror's details, and
the warning a navigation logs when it lands on a challenge, gave the page's URL whole: its user name and password,
its query and fragment (which can carry an OAuth code or a token) and all of its length. It is now cut as the frames
the report lists already were, to scheme, host, port and path, and capped like a URL; an address with no host
(data:,about:) keeps its scheme and path. - Two operators saving one new auth profile name at once are no longer both told it worked. A save checked the
profile's owner before writing the browser state and put its files in place after, holding only its own session's
lock, so a second operator's save of a name the first was still saving passed the check (no owner yet), and
whichever finished last replaced the profile the other had just been given. Saves of one name, or of names that
differ only in case or a trailing dot (one folder on Windows, and in case on macOS), now run one at a time, from the
owner check until the files are in place, so the second sees the first's owner and is refused. An import with
overwritestill checks the owner outside that lock. - The scripts refuse a controller address with an empty bracketed host. 1.16.0's check refused a base URL whose
host is empty (http://:8000/) but passed one whose host is an empty pair of brackets,http://[]:8000/,
http://[]/orhttp://[/, and left it to curl, which refuses the first two and reads the third as a glob. The
scripts now refuse all three before curl runs, as a host that is not a plain host name or address. - The raw CDP route checks what it is sent, and a DOM read no longer returns a typed password.
POST /sessions/{id}/cdp/rawtook itsmethodandparamsas they came: amethodthat was a list raised a
TypeErrorin the allowlist check (a 500), andparamswent to the browser whatever their names and types. A
methodthat is not a string, orparamsthat are neither an object nornull, now get 422, and each allowed
command takes only its own parameters, by name and type; any other gets 422 with the reason.DOM.getDocumentwith
"pierce": truereturned each input's user-agent shadow text, which is what was typed into it, so a password typed
into a page came back in plain text; aDOM.*read now blanks that text and thevalueattribute of any element
whosetypeattribute ispassword, andGET /sessions/{id}/cdp/element, which reads an element's attributes
itself, blanks thatvalueattribute too.docs/deployment.mdsays what is still returned: what was typed into a
field of any other type.
Fixed
- One session's witness receipts no longer wait for another's, and a hosted Witness service no longer slows
actions. Every receipt append took one recorder-wide lock, so each session's receipts queued behind every other
session's file writes; an append now takes a lock per scope and per chain file. A receipt for the hosted Witness
service (WITNESS_REMOTE_URL) was sent inline, under the session's lock, so a slow or unreachable service delayed
each action by up to its timeout. The receipt still goes to the local chain first; the hosted copy now goes from a
background queue (first in, first out, up to 1,000 receipts), and the session'switness_remotestate shows how the
newest receipt's delivery went once it lands or fails. A delivery that never reached the service (no connection was
made) is tried up to three times with backoff; any other failure, a 429 or 503 answer included, is not sent again,
since the payload carries no id the service could tell a second copy by. A full queue fails that receipt's delivery
(witness_remote.last_errorsays so), not the action. A close waits up to a second for its session's receipts
before it saves the closed record, and saves it again when one still on its way lands or fails, even when its own
save failed. Shutdown waits up to three seconds for the queue, logs what is left and fails its delivery (as it does
what a delivery worker that died left queued, and the receipt it died on), then waits up to three seconds more for
those closed records to be saved. The hosted Witness preflight before a confidential session's actions is unchanged. - A witness bundle's receipts and its chain check now come from one read of the chain. The export
(GET /sessions/{session_id}/witness/bundle,browser.export_witness_bundle) read the receipts, then read the
chain again to check it, so a receipt recorded in between gave a bundle whosehead_hashand chain check described
a receipt itsreceiptsdid not hold, whichscripts/verify_witness_bundle.pyfailed as "receipts missing". The
export now reads the chain once, under a file lock that an append to that chain waits for (shared on POSIX, which
its read-only handle can take on an NFS mount too, and exclusive on Windows). The chain check
(GET /sessions/{session_id}/witness/verify,browser.verify_witness) does the same: it walked the hashes of one
read and checked the signatures of another, so one verdict could describe two chains. - A witness receipt listing now says when it skipped a torn tail, and the bundle verifier explains one.
GET /sessions/{session_id}/witnessskipped a torn tail (bytes after the chain's last newline: an append cut short,
never a receipt) without saying so, where a bundle saystorn_tail: true; the listing now has atorn_tailfield
too.scripts/verify_witness_bundle.pyadds a note when a bundle left one out: the bundle's own chain check fails
on it until the controller's next append sets it aside, so export again after one. - A cancelled isolated-session create no longer leaves its browser container and network running. With
SESSION_ISOLATION_MODE=docker_ephemeral, a create cancelled (its caller gave up, or shutdown) while the controller
was creating the session's container and network let that work finish and dropped what it made, so the container
ran, holding the session's profile, until the next controller start swept it. The cancelled create now waits up to
ten seconds for that work and releases what it made (the container, the session network, the profile and downloads),
also when the work had just finished and a shutdown's cancel dropped its result on the way back; work that takes
longer releases what it made itself when it ends, even when a shutdown has ended the controller's event loop by
then. WithISOLATED_BROWSER_KEEP_CONTAINERS=truethe container is stopped and kept with its network, profile and
downloads, as a close keeps them. - With
ISOLATED_BROWSER_KEEP_CONTAINERS=true, a session whose browser container did not stop now closes as a
partial teardown. Nothing removes a kept container, and a failed stop was logged at debug level only, so the close
reportedteardown: completewhile the container could still be running. The failed stop is now a warning with the
daemon's reason, and the close reportsteardown: partialwithrelease isolated runtimein itsfailed_steps. - An isolated session's release now names the browser container's own failure when the Docker daemon fails midway.
A container lookup that failed (an unreachable daemon) escaped as the daemon's bare error before the session network
was touched, and a failed removal followed by a failed network lookup was logged as the network's error. The release
now still leaves the session network (and removes it when it can), logs each of the daemon's errors as a warning,
and fails withbrowser container <name> could not be looked up(orcould not be removed), caused by the daemon's
error; the session's profile and downloads stay, as before. - With Redis as the session store (
REDIS_URL), a close whose Redis write failed no longer leaves the session
reading as active. The closed record reached the durable file copy while Redis kept the record from before the
close, which reads and listings prefer; a later write was refused by the closed guard, nothing repaired Redis, and
the controller's next start marked the sessioninterruptedthere. A closed file copy (written first, so the
newest) now wins over the Redis copy in reads and listings, a closed one too when it missed a later save of the
record (its hosted Witness delivery state), and the next start gives Redis the closed record in place of an active
one. The close itself still fails, and drops the stale Redis copy when Redis answers; a write the closed guard
refuses gives Redis the closed record too. - With Redis as the session store, a session record's file copy deleted out of band no longer lets a late write
reopen the session. The closed guard read only the file copy, and a missing one meant "not closed", so a late
write after the close replaced the closed record Redis still held. For a record this controller process wrote (it
remembers the 10,000 most recent), a missing file copy now defers to Redis: a closed record there refuses the write,
and a Redis that cannot be read skips it until the next write. A new session's first write still asks nothing of
Redis. - A failed shadow browse now runs its whole rollback and reports its own error, and a close always records itself.
Marking a session-owned browser's pre-request gate before its close, and releasing the gate and the window-birth
watcher after it, could raise, and nothing caught it: the rollback of a failedenable_shadow_browsestopped there,
leaving the shadow session's directories and the active record its persist had written, and its caller got that
error instead of the one that failed the shadow; the rollback of a failed isolated create stopped before releasing
the isolated runtime; and a close of such a session skipped its audit event, witness receipt and closed record.
Those steps are now bounded and logged as the other teardown steps are, the rest runs, and a shadow browse's
rollback that still fails is logged while the original error is raised. - A teardown step cancelled on its own no longer ends a rollback or a close. A step whose own future was cancelled
(a context or browser close, or a hook, cancelled independently) while the task running it was not raised a
CancelledErrorthrough a failed create's or shadow browse's rollback, or a close: the isolated runtime was not
released, the record not closed, and a caller that was never cancelled got aCancelledError. Such a step is now a
failed step, logged, and the rest runs; a cancel of the task itself is still raised. No path in the controller is
known to cancel a step's future that way. The session-closed hook of the controller's extensions now runs as a
teardown step too, bounded at 30 seconds: one that never returned held the close, and its record, for ever. - A failed create's rollback now names a dangling symlink it leaves at a session path. On Linux,
shutil.rmtree
reports a dangling symlink at a session's artifact, auth or upload path as not found and leaves it, and the check
after it follows links, so the rollback said nothing about the link it left. It is now logged as not removed, as a
link to an existing directory already was; the rollback removes neither, and never goes through one. - A converging harness run no longer holds up the controller while retention removes an old skill candidate. A
converged run built and placed its candidate on the event loop, and placing it waits for the staging lock, which the
HARNESS_RETENTION_DAYSprune holds while it removes a candidate, so every request waited for that removal. The
candidate is now built and signed in a worker thread, and placed once the lock is free, which the event loop no
longer waits for, and the candidate a re-stage replaces is removed in a worker thread too; a run cancelled meanwhile
waits for that work, and its record names the candidate it staged. A shutdown that cancels the staging before the
candidate is placed places nothing, and the next start marks that run failed. - A staged skill candidate that
HARNESS_RETENTION_DAYSis removing no longer reads as tampered with. The
retention prune removed an aged candidate's files in a worker thread whileharness.get_candidate,
harness.list_candidatesand the drift checks read candidates without a lock, so a read in between found some of
its files gone: a signed candidate was refused as "not the one it was signed with" (listing logged it as
unverifiable), and a drift check failed with that error or reported the candidate degraded. The prune now renames
the candidate to a hidden name before it removes it there, under the staging lock that those reads now hold too, so
a read finds the whole candidate or none; a removal cut short leaves the hidden name, which the next start removes. - A drift check no longer writes its result beside another candidate, or brings back a removed one.
harness.check_driftandharness.check_all_driftsread a candidate, waited for the verifier, then wrote
drift.jsoninto whatever the candidate's directory held by then: a candidate re-staged meanwhile (a later run of
its contract) got the old one's result, and one retention removed got its directory back, holding onlydrift.json.
The result is now written only while the directory still holds the candidate that was checked; otherwise it is
returned with a note sayingdrift.jsonwas not written. - An OCR run that never finishes no longer holds its session for ever. OCR ran tesseract with no timeout, under
the session's lock (an observation, a screenshot and, with screenshots redacted, every action's before and after
snapshots), so a tesseract that hung held the session until it exited. A run is now stopped after
OCR_TIMEOUT_SECONDS(new, default 20; a value at or below 0 stops startup), logged as a warning naming the
setting, and counted as a failed OCR run (ocr_extraction_failed): a screenshot to be redacted then goes out
unscrubbed, saying so, or is withheld underPII_SCRUB_SCREENSHOT_STRICT..env.examplelists the setting. One
launch is still unbounded: thetesseract --versionthat pytesseract runs before the first OCR of each controller
process, and again until one succeeds, has no timeout, so a tesseract that hangs on it still holds that session. - An element's accessible name in an observation is capped at 200 characters. The accessibility outline kept each
node's name whole, and decoded the whole quoted name first, so a page that gave an element a megabytearia-label
put that megabyte into every observation and action snapshot that listed it or found it focused. A name is now cut
to 200 characters, as an element's text is, and only as much of it as gives those is decoded. - A page summary whose script fails no longer leaves its accessibility snapshot reading the page. The summary that
every observation but afastone and every action's before and after snapshot take ran its script and Playwright's
ARIA snapshot together and gave up at the first error, so the snapshot went on reading the page after the caller had
let go of the session's lock; it now waits for both, as the observation's other paired reads do, then raises the
error. - A screenshot capture cut off by a shutdown, or whose write fails, no longer leaves its image behind. A capture
whose read was cancelled has its file removed once the capture ends, since nothing checked what it shows; but a
shutdown cancels the capture itself, which then ended before Playwright's write of the file (in a thread of
Playwright's own) did, so the image was written after its removal and stayed in the session's artifact directory.
The controller now writes the image Playwright returns, in a worker thread that removes the file itself when it ends
after its capture was cancelled. A capture whose write failed partway (a full disk) left the part it wrote, at its
published name; that part is now removed before the error goes on. - A click or key press that opens a tab is verified by it, and its result names the tab. Observations and actions
stay on the active tab, which a tab a page opens does not become, so a click on a link that opened a new tab changed
nothing the action's verification compared and could readverified: false: an agent that retried opened a second
tab. An action's before snapshot now counts the session's tabs (tab_count), its verification reports
tabs_changedwhen the observation after it lists another number, which verifies a click or a key press, and its
result carriesnew_tab(the tab'sindexand how to move to it) when it opened one that is not the active tab.
Tabs are counted, not told apart: an action that opens one tab and closes another leaves the count, and so its
verification, as they were, andnew_tabnames only the newest of several. - A download's record no longer names the file's path on the server, and its URL works for any file name. Every
download record (the session's list, an observation'srecent_downloads,downloads.jsonl) carriedpath, a saved
file's absolute path on the controller's disk. It is gone:browser.read_downloadfinds the file by its name in the
session's downloads directory, and a stopped session's stored record leaves it out of the records it saved before,
wherever it is returned (its downloads list,GET /sessions/{session_id}and the session listing). A
downloads.jsonlwritten before keeps it on disk. A file name holding#or%gave aurlthat named another
path or none (#starts a fragment); the name is now quoted in it. A save that failed was recorded as
download_save_failedwith nothing logged; it is now logged as a warning naming the session. - A memory profile file that is no profile no longer breaks the others, or shows its content.
browser.list_memory_profilesfailed as a whole on a file inMEMORY_ROOTthat held a JSON list, or a
completed_stepswith no length (a number), listed objects that no get could load ({}, or steps given as a
string, counted by its characters), and skipped a file that did not parse without saying so. It now lists only the
files that load as a profile, as getting one does, and logs each other as a warning naming the file (and the error's
type, not its text). Getting, saving or deleting a profile whose file is not a valid profile failed with the
parser's error, which quoted the file (another operator's too); it now fails with "memory profile '' cannot be
read", and the file stays for its operator to fix or remove. A delete now waits for a save in progress, as saves
wait for each other, so a save's write no longer brings back a profile a delete just removed, nor a delete's unlink
removes one a save just wrote; a save or delete cancelled, once or more, holds the others off until its write or
unlink has landed. - An audit event written to SQLite now survives a power loss once committed. With
STATE_DB_PATHset, audit
events go to SQLite, whose connections ran WAL withsynchronous=NORMAL, under which the last commits can roll back
after a power loss or an OS crash. The audit store's connections now runsynchronous=FULL, a sync of the WAL per
event; approvals and harness traces keepNORMAL. A database whose journal mode stays out of WAL was logged at
debug level; it is now a warning. A connection whose configuration raised was left open, holding its file; it is now
closed before the error goes on. - The network inspector caps a request body by its bytes, and never reads a
text/event-streamor
multipart/x-mixed-replaceresponse. A request body was kept when its characters, not its UTF-8 bytes, fit
NETWORK_INSPECTOR_BODY_MAX_BYTES, so one of multibyte text was kept at up to four times the cap; it is now
measured in bytes, as a response body is. Atext/event-streamresponse counted as text and its body was read, and
Playwright'sresponse.body()waits for the end of a response, which an event stream need not reach, so the read
stayed pending for as long as the page kept the stream open. A response of either streaming type,
text/event-streamormultipart/x-mixed-replace, is now never read; its entry keeps no body. - A browser action, tab change, takeover request or auth save that took effect is no longer reported as failed when
its session's record cannot be saved. Once an action had taken effect and been recorded (itsactions.jsonlline,
audit entry and witness receipt), saving the session's record could still fail (a full disk, or Redis failing the
write), and that error reached the caller as the action's, so an agent that retried made the change twice. Opening,
switching to or closing a tab, a human takeover request, and saving a session's auth state or an auth profile from
it did the same, so an agent that retried a tab's close closed another tab. The failure is now logged with the
session id and the result is returned; the stored record catches up at the session's next save. - One mesh peer flooding the replay cache no longer locks every other peer out. A registered peer that got 10,000
signed envelopes through inside a timestamp window filled the 10,000-nonce replay cache, and every peer was refused
(503) until those nonces expired. Each peer now holds at most 1,000 of them: one at its share is refused with the
same503while the others' envelopes still pass. An envelope whose request does not decode is refused before its
nonce is recorded, since it can run nothing, and a replay of one that runs still meets its seen nonce.
docs/mesh.mdsays so. - An isolated-session create that gives up on its tunnel no longer waits for ever on an autossh that never exits.
WithISOLATED_TUNNEL_ENABLED, a create cancelled (or failing) while its autossh started killed autossh and waited
for it with no bound, so one stuck in uninterruptible I/O held the create until it exited. That wait is now bounded
at five seconds, as a release's has been since 1.16.0, and then logged as a warning naming the session and the pid.
A second cancel during that wait also left autossh's log open and its metadata (which names the bastion and its
user) on disk; both now go whatever ends the wait. - A token file whose mode cannot be read, and whose descriptor then fails to close, is reported for the read. When
the mode check ofTAKEOVER_TOKEN_FILEorAPI_TOKEN_FILEfailed to read the file's mode (an I/O error) and
closing the file failed too, the close's error replaced the read's, so the takeover token's warning gave the generic
"its mode could not be tightened" cause. The read's error is now the one raised, and the failed close is logged as a
warning of its own. - A controller serving without a token now rate-limits each client address, whatever headers a request carries.
UnderAPI_ALLOW_TOKENLESS_LOOPBACKwith no credential, every request counted as authenticated, so the request rate
limit keyed it by itsAuthorizationheader, else itsX-Operator-Idheader: values a sender mints at will, so one
that varied either was never limited, churned the limiter's buckets, and could fill the mesh replay cache from one
address. Such requests are now keyed by client address, as unauthenticated requests are, so clients behind one
address that each sent their ownX-Operator-IdorAuthorizationnow share that address's limit
(REQUEST_RATE_LIMIT_REQUESTS, 120 a minute by default); paths exempt from the limiter stay exempt in that mode.
docs/mesh.mdsays so. - The MCP bridges no longer answer a notification the controller never got. A notification (a message with no
id, such asnotifications/initialized) sent while the controller was unreachable, with an invalid controller
URL, or meeting an unexpected bridge failure got an error answer with"id": null, which a notification must never
get and which matches no request the client sent. It now gets none, as when the controller answers it, and the error
goes to the bridge's stderr. A notification the controller refused with an HTTP error (a401for a bad token, a
5xx), which was dropped without a word, is now reported on stderr the same way, redacted as an answer is; it still
gets no answer. - The MCP bridges and
scripts/agent_eval.pyrefuse a controller URL http.client cannot send, as an invalid one.
A base URL whose path or query holds a character outside ASCII, or whose fragment holds a space, a control character
or a character outside ASCII (urllib puts the fragment into the request line it sends an environment proxy), failed
only once a connection was chosen, and the bridges answered it as an unexpected bridge failure quoting http.client's
error. It is now refused before anything is sent, with a fixed reason, as a path or query holding a space or a
control character has been since 1.16.0; such a fragment is refused for a loopback controller too, which urllib
reached directly without sending the fragment, so a URL like that which worked must drop or percent-encode it. Both
also refuse a host or userinfo holding a character http.client cannot send (outside ASCII in the request line an
environment proxy gets, outside latin-1 in theHostheader), which the bridges answered as that failure, naming
the character and its position, and agent_eval failed on with http.client's error. The bridges' openers now handle
onlyhttp://andhttps://: urllib's default handlers, which they kept, answer afile:,data:orftp:
request from a local file, the URL itself or an FTP server, and an environment proxy of such a scheme turns a
request into one. Nor do they take an environment proxy for another scheme any more: withftp_proxyset, urllib
sent anftp://URL handed to such an opener to that proxy as an HTTP request, bearer token included, and took its
answer as the controller's. The bridges'urlopenitself now refuses a URL that is nothttp://orhttps://with
a host, as an invalid controller URL, before an opener is chosen, as their own requests have been refused since
1.16.0. agent_eval built openers of its own with urllib'sbuild_opener, which kept all of those handlers and that
proxy (its--executesent anftp://base URL's requests, token included, to anftp_proxy); it now opens
through the bridges'urlopen, so it follows each of these rules, and a base URL that is nothttp://or
https://with a host (localhost:8000), which failed with urllib's "unknown url type" error, is refused as an
invalid controller URL too. - The Python client and the LangChain tools no longer send a base URL's user name and password in place of the
token. Given a token, a base URL holding a user name or a password (http://user:pass@host) made httpx send them
asAuthorization: Basiccredentials, which replaced the token's header, so the controller got no token and the
caller was not told.AutoBrowserClient(withtoken,token_fileor anAuthorizationheader inheaders),
AutoBrowserToolandAutoBrowserTool.list_tools(withbearer_tokenortoken_file) andAutoBrowserNodenow
refuse that combination when built, with aValueErrorthat names the parts, never their values. Without a token,
the user name and password still go as Basic credentials. - The Python client and the LangChain tools now send a base URL's query with every request, at the request's own
path. httpx joined a request's path after the base URL's query (http://host/?key=valuesent
POST /?key=value/sessions, the path inside the query), and a GET with parameters of its own sent neither that
query nor the request's path (GET /?limit=5); the client'sstream_eventsalso put its path after a base URL's
fragment, so it asked for the base path alone. The query now goes as the parameters of every request, beside a
request's own (one of the same name replaces it), as the MCP bridges send the query of their URL, written as httpx
writes parameters (a space as+, a key with no value askey=); the fragment is never sent. - With
STEALTH_ENABLED, exporting a canvas no longer stops it taking a WebGL context, and the canvas patches read
as native code. The stealth script'stoDataURLasked the canvas for its 2d context to add its noise, which gives
a canvas that has no context yet a 2d one, so a page that exported a fresh canvas and then asked it for
getContext('webgl')orgetContext('bitmaprenderer')gotnull. The noise now goes only on a canvas the page
gave a 2d context, which a wrappedgetContextrecords; any other canvas is exported as it is. The patched
toDataURLandgetContext, and theFunction.prototype.toStringthat masks them, now read as native code
(function toDataURL() { [native code] }) with the native name and length; the script's WebGLgetParameterand
permissions patches, and thegetImageDatawrapperSTEALTH_PROFILE=lightadds, still show their source. Atype
whosetoStringthrows now throws before any export is made and leaves the canvas as it was, where the noise stayed
on its first pixel and the export was tried a second time, running thetoStringagain. Thetypeis converted
once before the canvas is touched, so what itstoStringdraws is kept (the export shows it), where the restored
pixel erased it; a Symboltypeis the native'sTypeErrorand leaves the canvas alone; a canvas with awidthor
heightaccessor of its own that throws is still exported, as the native export reads neither; and a receiver that
is not a canvas is refused before anything is converted. - With
STEALTH_PROFILE=light, a canvas read is noised per pixel and per colour channel. The noisegetImageData
adds came from the session's seed and the byte index, which is a multiple of 4 at every red byte, so every pixel got
the same shift, on red only, and a canvas read one of two ways in all, whatever the session. Each of a pixel's R, G
and B now goes one up or one down by a hash of the pixel's place on the canvas and the session's seed (alpha is left
alone), so the noise holds for the session and a pixel reads the same in any rectangle. A read of float values
(getImageDatawithpixelFormat: "rgba-float16") is now left as it is: a shift of one there is the whole 0-1
range, so a grey of 0.5 read as 0 or 1.5. The wrapper also checks its receiver before it converts a coordinate, as
the native does:getImageData.call({}, ...)is aTypeErrorthat calls novalueOf. And it converts the
coordinates one at a time and stops at the first the native refuses (not finite, or out of along's range): the
native'sTypeErrorcomes at that coordinate and no latervalueOfruns. A BigInt or a Symbol coordinate goes to
the native as it is, so itsTypeErroris the native's own message, and the wrapper calls theMath.truncit
captured at init, not the page's. - On Windows, the tests that run the repo's shell scripts no longer run them with a bash that cannot. Some ran the
firstbashon PATH, which can be WSL's launcher (WindowsApps\bash.exe), failing before the script ran; the rest
ran Git'sbin\bash.exewrapper, found besidegit, which puts/usr/binahead of a test's stubs. They now use a
bash.exein ausr\binfolder (Git's or MSYS2's), the first on PATH or else the one besidegit, or the bash
AUTO_BROWSER_TEST_BASHnames (controller/tests/_bash.py), and skip when there is none; on other systems, the
bash on PATH as before. On Windows what a script runs by name (bash, a stub's#!/usr/bin/env bash, and the tools
beside bash, such asrm) is found beside that bash, after the test's stubs.
Changed
- A
waitorreloadaction now reportsverified: nullin its verification, nottrue. Both readtrue
whatever the page did: a wait has nothing to verify, and a reload of a page that did not change leaves nothing to
compare. Itssignalsstill say what changed. A caller that testsverifiedfor truth now reads both as not
verified; the agent loop's no-progress check, which acts onfalseand otherwise compares the page before and
after, judges them as before. MESH_TIMESTAMP_WINDOWis now bounded: more than 0, and at most 250 seconds. Any other value stops startup with
"MESH_TIMESTAMP_WINDOW must be more than 0 and at most 250 seconds", as an unparseable one already did, with the
mesh off too. The window had no limit, and a nonce is kept for up to two windows, so at the default request rate
limit one address could fill the 10,000-nonce replay cache from a window of about 2,500 seconds, and a wider window
keeps a captured envelope replayable longer to a controller restarted with its clock set back. At 250 seconds one
address holds at most about 1,000 nonces at the default limit, one peer's share of the cache, and that only when it
stamps its envelopes about a window ahead of this node's clock; one whose clock agrees holds about half as many.
docs/mesh.mdand.env.examplesay so.- A
typing_timeoutis no longer retryable. It stops typing part way, and its message already said that part of
the text may have been entered and to check the field first, but it carriedretryable: true, so a client that
retries on that flag could type the part already entered a second time. It now carriesretryable: false; the code,
the status (504) and the message are unchanged.