Changelog

4.0.5

• Your own browser, through an extension for Chrome and Edge. DevMate could already drive a browser of its own; now your client reaches the one you use: bookmarks (tree, search, create, rename, move, remove), tabs and windows (list, open, go to, bring to front, reload, close, move, group), history (search, delete), downloads (list, start), recently closed tabs (list, bring back), the reading list, the most visited sites, and a tab's page (its text, a picture of what it shows or of the whole page). It debugs a page like DevTools: the console and uncaught errors, the network requests and one of them in full, the page as its elements with a number to act on each, one element in detail, what the page stores, click, type, press, choose, hover, scroll, run a script, answer a dialog, reload, and emulation of a screen, a color scheme or being offline; Chrome shows its own bar on a tab while it is debugged. They are capabilities of the engine chrome, used through capability_list, capability_query and capability_call without a project. The extension is also an entry like the editors: its panel says how things stand and what to do about it, starts DevMate, opens the workbench, copies the address a client needs, counts what waits for you and lists what DevMate did in the browser. It has two switches: Let DevMate use this browser (off: every request is refused and the client is told you paused it) and Start DevMate with the browser (off until you turn it on). It is loaded once, from a folder in DevMate's instance directory that stays where it is: every start of the runtime makes that folder, and the program the browser starts, the DevMate that runs, and the extension loads itself again when its files changed, so an update through any entry needs nothing done in the browser (Developer mode stays on). devmate chrome install registers DevMate with Chrome and Edge for your account (no administrator) and puts the extension into that folder, devmate chrome and the doctor say whether a browser is connected, devmate chrome uninstall takes it away. The browser starts DevMate's own small program for this one extension (native messaging): nothing listens for it and no public connection is needed.
• OpenAI's tunnel without a second program: devmate connect openai-tunnel --tunnel-id <id> is all it takes. DevMate speaks the tunnel's published protocol itself: this computer only reaches out to api.openai.com, nothing is installed or downloaded, up to 32 calls are served at once (maxConcurrentRequests), progress is passed on while a call runs, and the tunnel id in ChatGPT never changes. The doctor says whether OpenAI accepts the key and how many calls have arrived. A refusal is repeated in OpenAI's words with what to do about it: the key, the tunnel id, the tunnel's organization (--organization <id>), or an update when the protocol version is no longer taken. A tunnel that is connected but not offered in ChatGPT is said to be a matter of the OpenAI account, with the place where OpenAI explains it. OpenAI's own tunnel-client is used instead where --executable names it.
• A relay of your own: devmate relay setup user@host [--domain <name>] makes a public Linux server you control the way in. It installs Caddy there over your SSH key login, forwards one path nobody can guess to this computer through an OpenSSH remote forward, and by default answers only the addresses ChatGPT and Claude connect from and this computer. The address stays, answers stream, and nothing of a third party is in between. Reached by the server's address instead of a name, it needs Caddy 2.10: where the system's package is older or missing, the setup takes Caddy from Caddy's own package repository, and a Caddy that was there before is left alone, with the commands that would replace it. A relay has no sign-in (it forwards one path only), and setting both is refused. devmate relay remove user@host takes it off again.
• What the runtime itself asks of the outside (OpenAI's tunnel service, the check of its public route, a signing-in client's metadata document, external MCP servers) goes through the proxy the computer is set to use: the HTTPS_PROXY, HTTP_PROXY and NO_PROXY variables, or on Windows the system proxy of the account, followed within a minute when it is switched. devmate doctor says which proxy is in force and names a setting it cannot use.
• A model is shown its tools under the names it knows: ChatGPT and Codex get read, apply_patch, exec_command and write_stdin; Claude gets read, write, edit and bash (called powershell where commands run in PowerShell, so that the name never promises another shell); other clients get DevMate's own names. The client is recognised by what it says it is, or chosen with ?tools= in the MCP address, and devmate doctor says what the last client called itself, which list it was shown and why; every tool stays callable whatever list was shown. Everything that only reads, the capability tools and taking a change back are on every list; making a folder, moving and deleting are operations behind operations_call, which a patch or a command does as well.
• workspace_patch changes several files with one patch, all of it or none: the *** Begin Patch envelope Codex writes (update, add, delete, move) or a unified diff as git diff prints it (renames and quoted names included). A hunk is found by its text, so stale line numbers, differing indentation and typographic quotes do not stop it; one that fits nowhere is refused with the line where it stops matching, and one that fits in two places is refused instead of guessed. Should a write fail halfway, what was already written is taken back. Each file stays restorable and the whole patch is taken back with one workspace_restore.
• show_changes says what is uncommitted in a Git project, whoever changed it: per file what happened and how many lines came and went. Marked as reviewed, the next look shows only what changed since, and nothing when nothing did.
• A delegated agent can work in a copy of the project. agents_delegate with isolate:true starts the agent in a Git worktree of the last commit. The project does not change until its work is read (agents.proposal) and applied (agents.apply: all of it as uncommitted changes, or none of it when the project changed in the same places meanwhile) or discarded (agents.discard). Applied work is in the history, so it can be taken back like any other change; a link it brought is applied and named as the one thing that is not. The copy is kept beside DevMate's instance directory, never inside it.
• One call takes back a stretch of work. workspace_restore with since (the number of a workspace_history entry, shown there as #N) takes back every change DevMate's file tools made after that entry, newest first. A file something else changed in the meantime is left alone and listed, and taking back can itself be taken back.
• DevMate has one owner and no other accounts. Member accounts are gone, with their roles and their per-project grants: a sign-in that was issued to a member is refused, and every agent, command and job is the owner's. OAuth sign-in on a public address proves that the client is the owner's; the check DevMate makes of its own public route is the only other caller, and it is told which runtime answers and nothing else.
• A command runs without a terminal: nothing waits in a pager or at a prompt and no colour codes are written (NO_COLOR, TERM=dumb, PAGER, GIT_PAGER, GH_PAGER, GIT_TERMINAL_PROMPT), unless the owner's own environment says otherwise.
• The doctor says when this computer has no public address of its own and which routes work then, and what Windows PowerShell 5.1 costs with every command.
• runtime.metrics says for every operation how often it was called, by whom, how long half of the calls and nineteen in twenty took, and which errors it returned, and lists the newest failures.
• devmate doctor --report prints one text for a bug report: the checks, how the operations went, the newest failures and the last log lines, with credentials, private paths, account names and addresses taken out.
• A call that names no project while several are shared says in its answer which project it was answered from.
• What a connected client is told about the connection (connection_status with full access) never repeats the key a quick tunnel address ends in.
• A long-running capability is started with operations_call {operation:"job.start", …} and read with operations_query {operation:"job.read", …}.
• What every tool tells a client about itself (read-only, destructive, reaching outside) is part of the recorded public surface, so such a hint cannot change by accident.