Repository navigation
Keyfit 0.1.0
First published version. macOS only; Python 3.11 or newer, no other dependencies.
The Changed, Fixed and Security entries record what changed during development and three pre-launch
reviews, before anything was published.
Added
-
Shims for
claude,codex,aws,ghandvercel.keyfit setupwrites them and a small shell
file that puts them on PATH in new terminals (right after Superset's agent wrapper when it is
there, so its hooks keep working). You keep typing the commands as usual. -
zsh and bash.
keyfit setupwrites a PATH file for each;keyfit setup --rcadds the
line to~/.zshrc, or for bash to the login profile (and~/.bashrcwhen the profile sources
it).--shell zsh|bashoverrides$SHELL,--rc PATHpicks another file,--zshrc PATH
still works. On other systems than macOS,keyfit setupsays so and stops. -
Install with pip, pipx or Homebrew. Keyfit is a self-contained package (
pip install keyfit, a Homebrew formula for a tap); the shims and the Claude status line run the
installed package with the Python that rankeyfit setup.keyfit --versionprints the
version. -
claude-swap and codex-multi-auth on the first setup. In a terminal, the first
keyfit setup
asks whether to install each of these login switchers whose agent is installed and which isn't
yet (uv tool install claude-swaporpipx install claude-swap;npm install -g codex-multi-auth). Enter skips; running setup again asks nothing. -
Guided first run. In a terminal,
keyfit initregisters the repository, then offers what
it finds on this Mac one at a time: an AWS profile from~/.aws/config(orAWS_CONFIG_FILE),
a GitHub accountghis signed in to, the current Claude, Codex and Vercel logins, and a Linear key
(hidden input, stored in the Keychain). Enter skips; anything already set is left alone; it
ends withkeyfit status.--yes, or no terminal, registers without asking. -
keyfit setup --removeundoes setup: it deletes the shims and both PATH files and takes
Keyfit's line out of~/.zshrc,~/.bash_profile,~/.bash_login,~/.profileand
~/.bashrc(or only--rc PATH), leaving every other line as it was. The registry stays;
--purgealso deletes~/.config/keyfit, with the Claude and Vercel login folders Keyfit made, after
asking (--yesto skip the question).
Keychain items are never deleted. -
keyfit doctorchecks the installation with a ✔/✘ line each and the fix under every ✘:
macOS, Python, the shims, their place on PATH (before every real tool, right after Superset's
wrapper), the realclaude,codex,aws,ghandvercel, the registry, the Keychain and the
current folder's project. It never reads a secret. -
Projects recognised by folder.
keyfit initregisters a repository. Every subfolder and
every git worktree of it, wherever it lives on disk (Superset's included), belongs to that
project, and so do worktrees of repositories nested inside a project folder.keyfit which
tells you which project a folder belongs to and why;keyfit projectslists them all. In a
folder that is not registered, every tool runs exactly as before. -
Verified accounts per project. Before a tool starts, Keyfit hands it only the project's
accounts, removes conflicting credentials inherited from your shell, and checks each account.
When one is wrong or expired, the tool does not start and you see the command that fixes it.- AWS: a named profile and the account it must resolve to (
keyfit add aws, or imported
from ause awsline in.envrconkeyfit init); a profile found throughAWS_CONFIG_FILE
keeps that file.aws --profile <another project's profile>is refused inside a project. - Linear: one API key per project, read from an environment variable or the macOS Keychain,
checked against the expected workspace (keyfit add linear). - GitHub: the project's account from
gh's stored logins, checked against the expected login;
a different git author email or SSH host shows as a warning (keyfit add github). - Claude Code: the project's login, checked to be a claude.ai subscription in the expected
organisation, never down to one login (keyfit add claude,--newfor another account). - Codex: the project's ChatGPT login, never down to one account (
keyfit add codex). - Vercel: the project's login (the CLI's global config folder) and team, checked with Vercel's API
against the expected username and team membership (keyfit add vercel,--newfor another
login).vercelgets the folder (--global-config) and the team (--scope); inside a project,
--scopeor--global-configof another team or folder and--tokenare refused, and so is a
repository linked (.vercel/project.json,.vercel/repo.json) to another team. Inherited
VERCEL_ORG_ID,VERCEL_PROJECT_ID,VERCEL_TEAM_IDandVERCEL_TOKENare removed.
- AWS: a named profile and the account it must resolve to (
-
Sign-in always works.
aws sso login,claude auth login,codex login,gh auth …and
vercel login(alsologout,switch,whoami,teams) run even when a check fails, with the
project's environment (and forvercel, the project's login folder), so they fix the right account. -
MCP servers per project. In a project, Claude and Codex see only that project's Linear
server and never a server another project owns. Your servers keep their names. -
keyfit add mcp NAME…marks MCP servers (names or patterns such as'globex_cloud_*') as
belonging to the current project; every other project stops seeing them. -
Status line. Claude Code sessions started through Keyfit show the project and its
accounts, unless you configured a status line of your own. -
keyfit statuschecks every connection of the current project (--offlinefor local
checks only). -
Fast, forgiving checks. Successful remote checks are cached for 30 minutes. A network
blip is retried once, then a success from the last 24 hours is accepted with a warning; a
wrong account never is. -
Switches.
KEYFIT_DRY_RUN=1 <tool>shows what would run and which environment variables
would change (names only, never values).KEYFIT_DISABLE=1 <tool>skips Keyfit once.
Removing the shell line turns Keyfit off. -
Keys stored for you.
keyfit add linearwithout--keyasks for the key with hidden
input (or reads one line from stdin in scripts), checks it with Linear, then stores it in the
macOS Keychain.keyfit secret set NAMEstores any key the same way and prints its
keychain:keyfit/NAMEreference;keyfit secret listshows the names. Values never appear
in output or process arguments. -
The registry (
~/.config/keyfit/registry.toml) stores where secrets live, never their values. -
Documentation. A README for first-time users,
docs/security.md(everything Keyfit
reads, stores and sends, and its limits) anddocs/troubleshooting.md. -
Gmail, Drive and Calendar MCP servers on the project's Google account.
keyfit add google-mcp --server NAMEgives a project a Google Workspace MCP server that runs on the Mac with a login of its
own, signed in as the project's Google account (the work or the personal email ofkeyfit add google); servers of one Google account are shared by its projects ([accounts.google-mcp.NAME]).
Four servers are known by the package they run, with where each keeps its login: Google Workspace MCP
(workspace-mcp, a folder of<email>.json), Gmail AutoAuth (@gongrzhe/server-gmail-autoauth-mcp),
Google Calendar MCP (@cocal/google-calendar-mcp) and Google Drive MCP
(@piotr-agier/google-drive-mcp); any other server works with--login PATH. The login path comes
from the server's own definition (env) in the five agents' configs, else the server's default.
Before an agent starts, every definition of the server (yours and the folder's, in every agent) must
read that login, and every account in it must be the project's Google account (by the email it names:
the file's name,cached_email,emailor anid_token). Google must name that account too
(tokeninfo, Gmail's profile or the primary calendar), asked with the saved token while it is valid,
else with one renewed the way the server does: the login's refresh token and the server's own OAuth
client (from the Workspace server's login,GMAIL_OAUTH_PATHor~/.gmail-mcp/gcp-oauth.keys.json,
GOOGLE_OAUTH_CREDENTIALS,GOOGLE_DRIVE_OAUTH_CREDENTIALSor the Drive server's config folder) go
to Google's token endpoint, pinned, and the fresh token answers once and is dropped; nothing is
written to the login. This is the one place Keyfit uses a refresh token, so Gmail AutoAuth, whose
login names no account, is confirmed at every check, hours after its sign-in; a signed-out or revoked
sign-in fails with the server's own sign-in as the fix. Without a refresh token or OAuth client the
local check decides, and a login that names no account is a warning,account not confirmed, at
every agent start; a server not signed in yet is a warning too. Another account blocks the start,
with a fix that gives the server a login of its own (Keyfit never removes the other one). The servers
join the project's MCP ownership: every other project's sessions don't see them, in all five agents,
and a project with Google Workspace servers doesn't see any other Gmail, Drive or Calendar server
(Google's own remote servers included;keyfit add mcpstill gives one to a project). Sessions start
without inheritedGMAIL_CREDENTIALS_PATH,WORKSPACE_MCP_CREDENTIALS_DIR,
GOOGLE_MCP_CREDENTIALS_DIR,GOOGLE_CALENDAR_MCP_TOKEN_PATH,GOOGLE_DRIVE_MCP_TOKEN_PATHand
USER_GOOGLE_EMAIL, so each server reads the login Keyfit checked.keyfit initoffers the servers
signed in as the project's account;doctorshows each server, its login and the account it names.
claude.ai's own Gmail, Google Drive and Google Calendar connectors belong to the Claude account and
stay outside Keyfit's reach (documented). -
Gemini CLI, the fifth agent (thirteenth tool), on the project's Google account.
geministarts with
the project's accounts, checked, like the other agents, and signed in as the project's Google account
(the work or the personal email ofkeyfit add google). Gemini CLI keeps its settings, sessions and
Google sign-in in~/.gemini, andGEMINI_CLI_HOMEmoves that folder, so a Gemini CLI account is a
folder:keyfit add geminitakes your own~/.geminiwhen it is signed in as the project's account,
and--newmakes one (~/.config/keyfit/gemini/NAME, with yourGEMINI.md, commands, skills,
agents, policies and extensions linked in) that every project with the same Google account shares;
--keyuses a Gemini API key instead (checked with the Gemini API, kept in the Keychain or where
--key env:VARpoints, with a folder of its own set to the API-key method), and--cloud-project
hands a Workspace account its Google Cloud project. Every session of the project gets
GEMINI_CLI_HOME(and a key account'sGEMINI_API_KEY);geminiitself starts without inherited
GEMINI_API_KEY,GOOGLE_API_KEY,GOOGLE_CLOUD_PROJECT,GOOGLE_APPLICATION_CREDENTIALS,
GOOGLE_GENAI_USE_VERTEXAIand the other variables that would pick another key, sign-in method,
endpoint or credential store (GEMINI_FORCE_ENCRYPTED_FILE_STORAGEwould move the sign-in into one
Keychain item every folder shares). Before a start, the folder's sign-in method must be Google's,
and the email Google wrote into its sign-in (oauth_creds.json) must be the project's Google
account; while the sign-in's token is still valid, Google's tokeninfo must name that account too (an
expired token isn't renewed: that takes Gemini CLI's own OAuth client). Gemini CLI has no sign-in
command, soSign in now?runsgemini --prompt-interactive /quitin the project's folder: Gemini
CLI's own sign-in dialog, then it quits, and Keyfit checks the account before the session starts. A
wrong account names the sign-in file to remove in a folder Keyfit made, and a folder of the
project's own (--new) for your own~/.gemini. Sessions start with--allowed-mcp-server-names
naming every server they keep, when the project must not see one (from your settings, the folder's
.gemini/settings.json, the system's and your extensions, with your ownmcp.allowedand
mcp.excludedcarried over); an allowlist of your own that names another project's server is
refused, and Gemini CLI's own commands (mcp,extensions, …) run as typed.keyfit initoffers it
after Firebase;doctorshows the folder and the sign-in (a key only by its name). Verified with
Gemini CLI 0.64.0. -
Firebase, the twelfth tool.
firebaseand every agent session are checked against the
project's Google account (the onegclouduses too) and its Firebase project (keyfit add firebase: the project the CLI uses in the folder,--project-idfor another;keyfit add google
andkeyfit initnow also offer the firebase CLI's sign-ins). The firebase CLI already keeps
several sign-ins and binds one to each project folder (firebase login:use), so Keyfit keeps no
Google token: it reads the CLI's configstore and.firebaserc, and removesFIREBASE_TOKENand
GOOGLE_APPLICATION_CREDENTIALS, which would act instead of the sign-in;npx firebase-toolsin a
session uses the folder's binding. Before a start, the CLI must be signed in as the project's
Google account, its project folder (the nearest with afirebase.json) must use that account and
pick the expected Firebase project (firebase use, else.firebaserc); then Google's tokeninfo
must name the account for the access token the CLI keeps for it (the CLI renews an expired one
first, withfirebase projects:list), and the Firebase Management API must show the project.
Outside every Firebase folder the CLI uses its default login:firebasethen gets--account, and
agents a warning. Inside a project,firebaserefuses another--accountor--project(aliases
are resolved,-jPread like commander),--token, a--configfolder bound to another account,
firebase useof another project, alogin:usethat would bind a registered project's folder to
another account (or change the default login), and alogin --reauththat would replace the
default login.login,login:add,login:use,login:list,logoutanduserun without
checks.Sign in now?runsfirebase login:add(orlogin --reauthfor the default login), and
Bind this folder now?runsfirebase login:use EMAIL. A project without a Firebase account runs
firebaseas before.keyfit initoffers it after Google Cloud;doctorshows the sign-in and
project the CLI uses here. Verified with firebase-tools 15.26.0. -
Google Cloud, the eleventh tool, and the project's Google account. A project now says once which
Google account it uses, the work or the personal email (keyfit add google --email, or picked from
gcloud's sign-ins); every Google tool is checked against it (gcloudhere; Firebase and Gemini CLI
above).gclouduses the project's gcloud configuration (keyfit add gcloud: the one
signed in as that account, and its Google Cloud project,--project-idfor another). gcloud
already keeps named configurations, so Keyfit keeps no Google token: sessions andgcloudget
CLOUDSDK_ACTIVE_CONFIG_NAME(for that process only; the configuration active everywhere else is
untouched),CLOUDSDK_CORE_ACCOUNTandCLOUDSDK_CORE_PROJECT, sobqandgsutilin a session
use them too, and inheritedCLOUDSDK_…variables that pick another configuration, account,
project, credentials or endpoint are removed, withGOOGLE_APPLICATION_CREDENTIALS. Before a
start, the configuration must exist, its account must be the project's Google account and its
project the expected one, it must take no credentials from a file, and gcloud must hold a sign-in
for the account (read from the account column ofcredentials.db, never a credential); then the
tokengcloud auth print-access-tokenprints must belong to the account (Google's tokeninfo, the
token in the request body) and see the project (Cloud Resource Manager). Inside a project,gcloud
refuses another--configuration,--accountor--project,--access-token-fileand
--flags-file;gcloud auth login,auth list,config setandconfig configurations create,
listanddescriberun without checks in the project's configuration, except a sign-in as
someone else and aconfig set/unset,configurations deleteorrenamethat would move a
registered project's configuration off its account or project.Sign in now?runs
gcloud auth login EMAIL. A project without a Google Cloud account runsgcloudas before.
keyfit initoffers both after Convex;doctorshows the configuration and gcloud's folder.
Verified with gcloud 580.0.0. -
Bind this folder now? [Y/n]. When you start a tool yourself in a terminal and a Cloudflare check
fails only because the project's folder isn't bound to its wrangler profile (a new worktree, say),
Keyfit offers to runwrangler auth activate NAME FOLDERwith the project's wrangler, checks again
and starts the tool, likeSign in now?(both are asked, one after the other, when a sign-in is
needed too). In a Superset worktree it offers the folder that holds the repository's worktrees
(~/.superset/worktrees/<repository>), so later workspaces start without a question, unless a
worktree of another project is in it. Only the project's own profile, and only for a folder of the
project: never another project's folder or one outside every project, never the home folder or a
folder above it. Agents and scripts still get the printed command.keyfit add cloudflare's
Run it now?runs the binding the same way, away from the folder, so aCLOUDFLARE_API_TOKENin
its.envno longer makes wrangler refuse. -
Copilot CLI, the fourth agent (tenth tool).
copilotstarts with the project's accounts, checked,
likeclaude,codexandopencode, and as the project's GitHub account. Copilot CLI signs in to
GitHub and takesCOPILOT_GITHUB_TOKENbeforeGH_TOKEN,GITHUB_TOKEN, its own login and gh's, so
a Copilot account is a GitHub login gh holds:keyfit add copilotrecords the project's GitHub
account (--loginfor another), and every session of the project gets gh's token for it in
COPILOT_GITHUB_TOKEN(npx @github/copilotinside a Claude session too). Copilot's own folder
(~/.copilot, orCOPILOT_HOME) stays shared. Before a start, gh must hold a token for the login
that isn't a classic personal access token (ghp_…, which Copilot refuses), andapi.github.com/user
must return the login, as for GitHub; a token the project's GitHub check already confirmed is reused
without asking gh again. Inherited Copilot tokens (also the coding agent'sGITHUB_COPILOT_…_TOKEN),
COPILOT_GH_HOST,GH_HOSTandCOPILOT_PROVIDER_…(a model provider of your own instead of the
account) are removed. Sessions (copilot,-p,init,workflow) start with
--disable-mcp-server=NAMEfor each server another project owns, frommcp-config.json,
.mcp.jsonand.github/mcp.jsonup to the repository's top and--additional-mcp-config;
--enable-mcp-serverof such a server andcopilot -C DIRwith a folder of another project are
refused, and so iscopilot loginwhere the project has a Copilot account (it would change only
Copilot's own login). The fixes are gh's sign-ins, which Keyfit prints and never runs.keyfit init
offers Copilot CLI right after OpenCode when the project has a GitHub account;doctorshows the
account and Copilot's folder. Verified with Copilot CLI 1.0.97. -
OpenCode, the third agent (ninth tool).
opencodestarts with the project's accounts, checked,
likeclaudeandcodex. OpenCode 2 keeps every sign-in in its SQLite database, which
OPENCODE_DBmoves, so an OpenCode account is a database:keyfit add opencoderecords OpenCode's
own one (~/.local/share/opencode/opencode.db) and the providers signed in there;--new --name NAMEmakes another under~/.config/keyfit/opencode. Before a start, the database must hold a
sign-in for each recorded provider (read-only, never a credential) andopencode auth listmust
see them, with no shell key next to them; no provider is asked (there is no cheap call that
confirms a sign-in), and the check starts OpenCode with no configuration, so no MCP server starts.
Sessions (opencode,run,mini), sign-ins (auth …),models,statsandsession …get
--standalone: OpenCode's background server serves every folder and keeps the environment of the
start that launched it, so Keyfit never starts it with a project's environment and runs its own
commands (mcp,serve,service, …) unchanged from your terminal; inside a session, where the
environment holds a project's accounts, they get--standaloneor are refused. In a project with an
OpenCode account,opencodestarts without inheritedANTHROPIC_API_KEY,OPENAI_API_KEY,
GEMINI_API_KEY,GOOGLE_GENERATIVE_AI_API_KEY,GOOGLE_API_KEY,GITHUB_TOKENand
OPENCODE_API_KEY, or any other key or token OpenCode's own report (opencode auth list) names
as coming from your shell (OPENROUTER_API_KEY,GROQ_API_KEY,AWS_BEARER_TOKEN_BEDROCK,
CLOUDFLARE_API_TOKEN,GITLAB_TOKEN, …): the check warns "from your shell, not the project's
account" and keeps their names (never values) with the cached result, so cached starts remove them
too, and a new key-like variable is checked again. Only names containingKEYorTOKENcount, so
theCLOUDFLARE_ACCOUNT_IDKeyfit sets stays. Claude, Codex and Copilot CLI sessions keep them all;
Gemini CLI sessions keep them too, apart from the Google keys its own account removes
(GEMINI_API_KEY,GOOGLE_API_KEY). Other projects' MCP servers are
switched off inOPENCODE_CONFIG_CONTENTfor the folder OpenCode opens (your own content is kept).--server,acp --loginandopencode DIRwith a
folder of another project are refused.Sign in now?runsopencode auth login PROVIDER --standalone;
keyfit initoffers OpenCode's sign-ins;doctorshows the project's database. Verified with
OpenCode 2.0.25. -
Convex, the eighth tool.
convexandnpx convexuse the project's Convex account. The convex
CLI keeps one login per Mac (~/.convex/config.json) and has no account switch, so Keyfit hands each
session the project's token inCONVEX_OVERRIDE_ACCESS_TOKEN, which the CLI takes before its own
login and before deploy keys. An account is the CLI's own login (keyfit add convex --cli, read
whenever a session starts) or a token Keyfit keeps in the Keychain (--copycopies the CLI's current
login, or paste one;--token env:VAR), plus the team. Before a start, Convex must accept the token
and list the team (GET api.convex.dev/api/teams, whatnpx convex login statusshows), and the
deployment the folder points at (CONVEX_DEPLOYMENTor a deploy key, from.env.localor.env)
must belong to that team. InheritedCONVEX_DEPLOYMENT,CONVEX_DEPLOY_KEYand
CONVEX_DEPLOYMENT_TOKENthat the folder's files disagree with are removed, and so is
CONVEX_PROVISION_HOST. Inside a project,convexrefuses--admin-key, another--team, and
another team's deployment named with--deployment,--deployment-nameor--env-file;
convex loginandlogoutare refused where Keyfit keeps the project's token. When the account is
the CLI's own login and it expired,Sign in now?runsnpx convex login --force. A project without
a Convex account runsconvexas before.keyfit initoffers the CLI's login;doctoraccepts a
convex used only through npx. -
Cloudflare, the seventh tool.
wrangleruses the project's Cloudflare account. wrangler keeps
named sign-ins bound to folders since 4.106 (wrangler auth create NAME,wrangler auth activate NAME DIR), so Keyfit keeps no Cloudflare token: an account is a wrangler profile plus the expected
account ID (keyfit add cloudflareoffers the profiles and the accounts the chosen one reaches).
Before a start, the folder must resolve to the profile (bound there or above, not shadowed by a
subfolder bound to another profile), the wrangler config wrangler would read must name no other
account_id(env.*too), the wranglernpxwould run must be 4.106 or newer, andwrangler whoamiin the folder must list the account.wrangler,claudeandcodexstart with
CLOUDFLARE_ACCOUNT_IDset to the account and without inheritedCLOUDFLARE_API_TOKEN,
CLOUDFLARE_API_KEYandCLOUDFLARE_EMAIL(they beat every profile), sonpx wranglerand
npm run deployinside a session work on the project's account or fail. Inside a project, another
--profile, a--cwdor--configpointing elsewhere,wrangler login/logout(they change only
the default sign-in) andwrangler auth activate/deactivate/create/deletethat would move a
registered folder off its project's profile are refused. A project without a Cloudflare account runs
wrangleras before.Sign in now?runswrangler auth create NAME;keyfit initoffers the
profile bound to the folder;doctorshows the profile, its binding and the account. -
Supabase, the sixth tool.
supabaseuses the project's Supabase account: a personal access token
Keyfit keeps in the Keychain (keyfit add supabasechecks it with Supabase and records its
organization;--clicopies the token of the supabase CLI's current login;--token env:VARnames
one you keep elsewhere). It reaches the CLI asSUPABASE_ACCESS_TOKEN, with
SUPABASE_PROFILE=supabase, sonpx supabaseand a Supabase MCP server reading
${SUPABASE_ACCESS_TOKEN}in a Claude or Codex session use it too. Before a start, Supabase must accept
the token and list the organization, and a linked folder (supabase/.temp/project-ref,
SUPABASE_PROJECT_ID) must point at a project of it. Inside a project,--project-ref,link REF,
projects delete REF,gen types --project-idand--workdirpointing at another organization's
project are refused, and so are--org-idof another organization and another--profile.
supabase loginandlogoutare refused there too, since they change only the CLI's own login.
A project without a Supabase account runssupabaseas before (it is often used only locally).
keyfit initoffers the CLI's login. -
Sign in now? [Y/n]. When you start a tool yourself in a terminal and every failed check is fixed
by a plain sign-in (aws login,aws sso login,claude auth login,codex login,vercel login,
wrangler auth create NAME,npx convex login --force),
Keyfit offers to run it, checks again and starts the tool. Without a terminal (agents, scripts, CI)
nothing is asked. gh's sign-in is never run for you, since it switches gh's active account.
Changed
- Faster starts, about 30–55 ms per launch. urllib and TLS load only when a check goes online,
shims runpython3 -I -S, GitHub's two git questions run side by side, andghinside a session
Keyfit started keeps the token its project's check confirmed in the last 30 minutes (until gh's
sign-ins change). Runkeyfit setupagain to rewrite your shims.scripts/bench_shim.pymeasures
what a shim adds on your Mac. - First run reads like a guide.
keyfitalone prints its help with a "start here" list;setupand
initcome first in it, and every command's--helpsays what it does. Afterkeyfit setup --rc,
Keyfit says what to do next; with--rc FILEit prints the matching--remove --rc FILE.
Runningkeyfit setupagain (after an upgrade) says when your startup file already loads the shims.
The line it adds ends in# keyfit: tool shims on PATHinstead of naming four of the tools; the
line of earlier versions still counts (setup --rcrewrites it in place,setup --removeand
doctorfind it, and a shim whose Keyfit is gone names both). keyfit initrefuses your home folder (and any folder above it), and a--rootthat doesn't
exist: every folder under it would have belonged to one project. Outside git, it says that every
folder below belongs to the project. It also says when Keyfit isn't active in this terminal yet.keyfit statussays which ofaws,ghandvercelwon't start in the project until their
account is mapped, and how to register a folder that isn't.- Every error names the next command. A tool that isn't installed shows how to install it; an
unmappedghshowskeyfit add github --login <login>;keyfit add awslists the profiles there
are; a rejected AWS access key points ataws configure --profile P, which runs inside the project. - A shorter README. It now covers what Keyfit is, install, a first project, everyday commands
and limits. Everything about each kind of account (what the tool gets, what is checked and refused,
how to set it up, its limits) moved to one section per account indocs/accounts.md.
Removed
- WorkOS and Bitwarden Secrets Manager support from the private prototype are not part of the
public version.
Fixed
- A mistake in
registry.toml(a typo,rootswritten as a string, a root that is the home folder)
is reported with its place and the fix instead of a Python traceback, inkeyfitcommands and in
the shims. A connection that names a missing account, or a misspelled one, fails only its own
project's check. - With Python older than 3.11 (macOS's own
python3is 3.9), Keyfit says which version it needs
instead of failing onimport tomllib. - Shims whose Keyfit installation is gone (uninstalled before
keyfit setup --remove, or moved) say
what to do instead of sh's "No such file or directory". The tool still doesn't start. KEYFIT_DRY_RUN=1started commands Keyfit lets through without checks:supabase,wrangler,
convex,gcloudandfirebasein a project without an account of their kind
(KEYFIT_DRY_RUN=1 wrangler deploydeployed), OpenCode's own commands (opencode serve, …) and
AWS profiles undershared_aws_profiles. They are now printed with the reason, the command and
the names of the variables that would change, like a checked start. Sign-in commands, other
commands in a folder that isn't registered, andKEYFIT_DISABLE=1still run, as documented.cloudflarelines inkeyfit status,doctorand failed checks started one column later than
the others: the kind column is now ten characters wide.- Guided
keyfit initon a Mac without Codex saidno clean ChatGPT login in ~/.codex … sign in (codex login); it now sayscodex not found on PATH — skipped, like the other tools. - Python 3.14 is tested and listed in the package's classifiers. CI now also runs the tests that
install a built wheel (they were skipped on every Python), and a release installs its wheel into a
fresh virtualenv and runskeyfit --versionandkeyfit setupbefore anything is published.
Security
From the pre-launch security review:
- A
.gitfile or symlink no longer lends a folder another project. A folder (for example an
unpacked archive) whose.gitpointed at a registered repository resolved to that project. A
worktree now counts only when its repository lists it; a moved worktree needsgit worktree repair. - Unclear command lines always run the checks.
claude --add-dir authorcodex -C loginwas
taken for a sign-in command and started a session without checks. aws --prof otheris refused like--profile other: the AWS CLI accepts abbreviations.- A session whose project is no longer registered runs no
aws,ghorvercelinstead of
running them unchecked. - An account kind Keyfit does not know (a typo such as
githb) fails its check instead of warning. - No key in error output. A malformed
~/.aws/credentialsline (which can be a secret key) was
printed in the "internal error" message; internal errors now show the exception type and place
only. A key typed where a reference or name belongs (--key lin_api_…,secret set lin_api_…) is
refused without being repeated, and hidden prompts never fall back to echoing. - Keys go only to their own service. Only values shaped like a Linear key are sent to Linear
(--key env:VARand.envrcimports could name any variable), and Keyfit's HTTPS checks no
longer follow redirects, which would have carried the key or token to the new address. - Owner-only files from the first byte: the registry, the check cache and a new Claude
account's.claude.json; the cache folder and Claude account folders are 700. - Control characters are escaped in check output, so text from a repository
(.vercel/project.json) cannot drive the terminal. - The loop guard counts every launch, so a wrapper that calls a tool by name stops after a few
rounds in unregistered folders too. bin/keyfitruns Python isolated, so a repository it runs in cannot replace a module.- Codex never sees a server it cannot hide. Codex splits a
-ckey on every dot and does not
understand quotes, so a server name with a dot or=that had to be hidden either stayed visible
or broke the start. Such a server now stopscodexwith a message to rename it; names with inner
spaces are passed bare, which Codex understands. - A new Claude login trusts no more than your default one.
keyfit add claude --newpre-trusted
every folder of the project; trust is what lets a repository's own hooks and settings run, so it
now carries over only folders your default login already trusts. - Release workflow: actions pinned to commit hashes,
buildandtwineto versions. docs/security.mdnow says plainly what Keyfit sees, stores, sends and does not protect against.
From the second pre-launch review:
- wrangler's other spellings of
--configare refused too. wrangler's parser also reads-cwith
the value attached (-c/path/wrangler.toml,-c~/…), in a group of short options (-ec FILE,
-ec./FILE), as-c=FILEand as--c FILE. A config of another account, or in a folder bound to
another wrangler profile, given that way reached wrangler without the refusal.wrangler devwith
several configs has each one checked. - A folder's
.envno longer decides where a wrangler sign-in goes. wrangler loads.env,
.env.localand.env.<env>into its environment, also for Keyfit's ownwrangler whoami, so a file
there could setCLOUDFLARE_API_BASE_URL(the host every request, with the profile's token, goes to)
or the sign-in endpoints wrangler renews a sign-in at. wrangler now always runs with
CLOUDFLARE_API_BASE_URLset to Cloudflare's own API (a variable already set beats.env), without
inheritedWRANGLER_AUTH_DOMAIN,WRANGLER_AUTH_URL,WRANGLER_TOKEN_URL,WRANGLER_REVOKE_URLand
WRANGLER_CLIENT_ID, and a.envfile that sets any of them fails the check before wrangler runs,
naming the file and the variable, never the value. wrangler's sign-in commands, a--cwdfolder and
--env-filefiles are held to the same. A project that deliberately uses another Cloudflare host
(staging, a compliance region) isn't supported yet.
From the third pre-launch review:
- Claude's background sessions no longer run with another project's accounts. Claude Code runs
them (claude --bg, agent view,←and/background,claude respawn) under one supervisor per
config folder, which keeps the environment of the start that launched it and gives it to every
background session, in any folder. A supervisor started in a project kept that project's accounts
for all of them, and Keyfit's check of the folder never applied. Claude sessions in a project now
start with background sessions and agent view off ("disableAgentView": truein--settings,
CLAUDE_CODE_DISABLE_AGENT_VIEW=1), andclaude --bg,agents,attach,respawnand
daemon runare refused in a project and inside a session.claude daemon status,logsand
stoprun as typed (Keyfit's--settingsin front ofdaemonkept them from running). A
supervisor that already runs keeps what it got: stop it once in a terminal outside every project,
withclaude daemon stop --any. A project whose Claude login has a config folder of its own
(keyfit add claude --new --name NAME: not~/.claude, and no other project's Claude account in
it) gets background sessions back, since that folder has a supervisor of its own: there
claude agents,--bg,attachandrespawnrun, checked, sessions start with agent view on, and
claude agentsgets Keyfit's--settingsfor the sessions it starts. A supervisor already running
for that folder must have that project's environment (Keyfit reads its pid and start time in the
folder'sdaemon.lock, and itsKEYFIT_PROJECTwithps -E); otherwise those commands are refused,
namingCLAUDE_CONFIG_DIR=… claude daemon stop --any.claude daemon runstays refused, and the
other refusals now namekeyfit add claude --new.keyfit add claude --newalso linksplugins
from~/.claude: Claude keeps the pluginssettings.jsonenables in the config folder. - Codex's shared server no longer gets a project's accounts either. It keeps the environment of
the start that launched it, for every folder.codex resumeandcodex forknow start with
--no-daemon, likecodex, andcodex agents,queue,remote-controlandapp-server, which
work on that server, are refused in a project. One that already runs: stop it with
codex app-server daemon stop, outside every project. Inside a session, in a folder outside every
project, Codex is held to the same:codex,resumeandforkstart with--no-daemon, and the
server's commands are refused (they ran unchanged with the session's accounts). - Two clients' setups are no longer merged silently.
keyfit initin a second folder with a
registered project's name (~/work/globex/apiafter~/work/acme/api) added it to that project:
it ran with acme's accounts, and its own.envrcwas never imported.initnow stops and asks for
a name of its own (--name globex-api); naming the existing project (--name api) still adds the
folder, and says so.keyfit add codex,claude,vercelandopencodewithout--namegave a
second login the first one's default name (two ChatGPT pro loginspro, two personal Claude logins
personal, two Vercel logins in one team), which replaced the first project's account with the
second's; the second login now gets the next free name (pro-2). A--nameshared on purpose but
given another login (also forgithubandcopilot) changes it for every project using it, as
before, and now names them;githubno longer keeps the old login's email and ssh host then. --namemust be a name.keyfit add claude,opencodeandvercel --new --name ../../x
created folders outside~/.config/keyfit;--nameof everykeyfit addis now letters, digits,
.,_and-.- Supabase: an option before the command no longer hides it.
supabase --agent no projects delete <ref>andsupabase --agent yes gen types --project-id <ref>ran on a project of another
organization: Keyfit took--agent's value for the command.--agentand--output-formatnow
count as options with a value, and every word shaped like a project ref is checked wherever it
stands (gen … --project-idtoo), so an option Keyfit doesn't know can't hide one either. - Supabase: the TypeScript CLI's other links are checked. Its
branchescommands act on the
parent project insupabase/.temp/linked-project.json, and its stack mode links through
supabase/.link.json; a project of another organization named there now fails the check, like one
insupabase/.temp/project-ref. - Vercel: a folder to deploy is checked like
--cwd.vercel deploy <path>,vercel <path>and
vercel dev <dir>use that folder's link and take the team from it, whatever--scopesays. A
folder linked to another team is now refused. - Vercel:
.vercel/repo.jsonin its current format.vercel link --reporecords a team per
project, and Keyfit read only the older top-levelorgId, so a repository linked to another team
that way passed the check. It now takes the project whose directory holds the folder (else every
project), like the CLI. - Convex reads
.env.local,.envand--env-filefiles the way the convex CLI does. The CLI
parses them with dotenv, which skips a byte-order mark, reads invalid UTF-8 as replacement characters,
acceptsKEY: valuelines and lets a quoted value span several lines. Keyfit read them line by line,
so a file written any of these ways could point the folder at another team's deployment while the
check said "login and team confirmed". Keyfit now parses them with dotenv's own pattern. A file that
decides the deployment but can't be read fails the check (.env.local cannot be read, …), and an
--env-fileKeyfit can't read is refused. - A deploy key in
CONVEX_DEPLOYMENTis never sent or printed. A key put there (prod:NAME|…) went
to Convex in the deployment lookup's address and appeared in the failure line and inkeyfit add convexerrors. Only a deployment name (likehappy-animal-123) is now sent or printed: such a
CONVEX_DEPLOYMENTfails the check before the network, and--team,--deploymentand
--deployment-namevalues holding a key, or a--deployment-namethat isn't a deployment name, are
refused without being repeated. - Inherited
CONVEX_SELF_HOSTED_URLandCONVEX_SELF_HOSTED_ADMIN_KEYare removed in a project with
a Convex account, unless the folder's own files set the same. The CLI takes them before
CONVEX_DEPLOYMENT, so another project's self-hosted deployment hid the folder's own, unchecked. - gcloud no longer acts as another identity in a project.
--impersonate-service-accountis
refused, and a configuration that setsauth/impersonate_service_account,auth/token_host,
auth/mtls_token_host,auth/disable_ssl_validationor anapi_endpoint_overrides/…fails its
check, withgcloud config unset … --configuration NAMEas the fix (it now runs while checks fail).
Before, an impersonating configuration was reported as "me@acme.io as deployer@… · account and project
confirmed".gcloud config set auth/…andapi_endpoint_overrides/…on a configuration a project
uses are refused. - gcloud's and firebase's other spellings are read like the CLIs read them. A leading release track
(gcloud beta config configurations delete globex,gcloud alpha config set account other@x.com)
and arguments after--(gcloud auth login -- other@x.com,firebase use -- other-project,
firebase login:use -- other@x.com) slipped past the refusals, and so didgcloud auth login --remote-bootstrap URL other@x.com.gcloud auth loginwithout the project's account andgcloud auth activate-service-accountas anyone else are refused in a project with a Google Cloud account:
they write whichever account signs in into the project's configuration. - firebase is checked on the project its CLI really picks. firebase.json's deprecated
"firebase"
key, which the CLI takes before.firebaserc, was ignored; and without afirebase.json(a
monorepo's top) the.firebasercthere was not checked, thoughfirestore:delete,database:get
orauth:exportact on its default. keyfit add gcloudnever takes another account's configuration. It took the only configuration
whatever its account (the default one, active everywhere else) and printedgcloud config set account … --configuration default, which would move every gcloud outside projects to the project's
account. It now namesgcloud config configurations create … --no-activate, askeyfit initdoes.- firebase's sign-in can't be sent elsewhere. Inherited
FIREBASE_TOKEN_URLand
FIREBASE_GOOGLE_URL(where the firebase CLI posts the refresh token), the CLI's other
FIREBASE_…_URLendpoints andFIREBASE_CLIENT_ID/_SECRETare removed, also for Keyfit's own
renewal withfirebase projects:list. - A git that can't answer no longer makes a project folder look unregistered. When git failed
(Command Line Tools broken by a macOS update, Xcode's licence not accepted, git missing or slow,
dubious ownership, a.gitfile naming a folder that is gone), a registered folder counted as
one outside every project: tools started with your shell's credentials, without checks and with
every MCP server, andkeyfit doctorsaidAll good. Inside a repository (a.gitthere or
above), tools now don't start and show git's message; folders without one run as before.
keyfit doctorhas agitline. The lookup also ignores theGIT_DIR,GIT_WORK_TREE,
GIT_COMMON_DIR,GIT_INDEX_FILEandGIT_CEILING_DIRECTORIESa git hook exports: a tool a hook
ran in a worktree's subfolder resolved to no project. - Submodules and nested repositories in a worktree belong to its project. In a Superset worktree,
git's top folder is the submodule's and no registered folder sits above it. When a repository isn't
registered, Keyfit now resolves the checkout around it before trying registered parent folders. - A failed check no longer leaves its cached success behind. After
keyfit statusshowed ✘ (a
profile that now signs in to another account, say), launches kept starting the tool on the success
cached up to 30 minutes before. Any other answer now removes it, and only successes are cached
(with the names of the shell keys OpenCode reported); warnings such asaccount not confirmed
were cached for 30 minutes too. - A success trusted while a service can't be reached is shown for every tool.
aws,gh,
vercel,supabase,wrangler,convex,gcloudandfirebasestarted on one up to 24 hours
old without thecould not re-check nowwarning. - No
Sign in now?inside a session Keyfit started (KEYFIT_PROJECTset): agents run commands
in a terminal of their own, where anawswaited for an answer. - MCP servers acting on another workspace are hidden wherever they are defined. A Linear server was
recognised only by the exact addressmcp.linear.appand the first${VAR}of its headers, so a
server with another workspace's key in itsenv(Claude's form and Codex'senv = {…}),
npx mcp-remote https://mcp.linear.app/mcp --header "Authorization: Bearer ${LINEAR_GLOBEX_API_KEY}"
andhttps://MCP.LINEAR.APP/mcporhttps://mcp.linear.app:443/mcpstayed visible in every project.
A Linear server is now one withmcp.linear.appin its address or command, or aLINEAR_…variable
or a Linear key in itsenv; it stays visible only when every variable it names holds the project's
key and a key written into it is the project's own. One signed in inside the agent (OAuth) is hidden
unless a project claims it:keyfit add mcp NAMEnow works for Linear servers too. Keyfit now also
reads Claude's local scope (claude mcp addwithout--scope: the folder's entry in~/.claude.json,
also for the repository's top and a worktree's main checkout), Codex's profile file
(codex --profile NAME:NAME.config.tomlnext toconfig.toml) and the.codex/config.tomlof the
folders Codex trusts, so servers defined there are hidden, and a Google Workspace server defined
there is checked. A.mcp.json,opencode.json, Copilot CLImcp-config.jsonor Gemini CLI
settings.jsonwith a byte-order mark or a leading//comment counted as empty; it is read now,
and a config file an agent loads that still can't be parsed stops the agent with a message instead
of starting it with servers Keyfit couldn't see. - wrangler's config is found the way wrangler finds it. Given an entry file (
wrangler deploy ../other/src/index.ts, alsoversions upload,dev,previewand--script), wrangler reads the
config of that file's folder, whoseaccount_idbeats the account Keyfit pins; such a config of
another account is now refused like--config. The config a build generated, which
.wrangler/deploy/config.jsonsendswrangler deployto (the Vite plugin's
dist/<name>/wrangler.json), is checked too, so a stale one no longer keeps an old account. - A wrangler config Keyfit cannot read fails the check instead of being skipped. A byte order mark
and bytes that aren't UTF-8 are read as wrangler reads them (awrangler.tomlof another account
with a byte order mark passed), so is a//comment ended by a lone CR, and what Keyfit still cannot
parse (TOML 1.1 syntax) is refused with a message that says so. --cwdfollows symlinks, as wrangler does, so a link into another project's folder is refused,
and a refusal about another project's folder no longer suggests binding it.- wrangler's binding commands are checked everywhere.
wrangler auth activate,deactivateand
deletetyped outside every project ran unchecked, and so did binding a folder that holds projects'
folders (..,~/code,~/.superset/worktrees/<repository>) to another profile, or unbinding it;
they are now refused when they would move a project's folder (a root or a worktree) off its
profile.keyfit add cloudflare'sRun it now?binds the project's own folder when the
repository holds more than the project (~/mono/apps/webin~/mono), under the same rules as
Bind this folder now?. - wrangler's options are read as wrangler reads them:
--env NAMEloads.env.NAMEwherever that
path leads (--env /../settings.txtloadssettings.txt), and--config -0x.tomland--config -
name files. - Both wranglers must be new enough for profiles: the one
npx wranglerruns (also pnpm's script
innode_modules/.bin, whose version went unread) and the onewranglerruns from PATH. A version
Keyfit cannot tell is a warning instead of passing silently. - The online Cloudflare check gets none of the project's other tokens. At an agent start it ran the
repository's ownnode_modules/.bin/wranglerwith every account of the project in its environment
(a Convex or GitHub token, say); it now runs with your shell's environment and the Cloudflare
account only. - A folder's
.envcannot move wrangler's profiles.XDG_CONFIG_HOMEthere would have wrangler
read and write its profiles and bindings where Keyfit doesn't look (andSign in now?sign in
there); it now fails the check like the sign-in endpoints. - Sign-in commands are only the sign-ins, so they no longer print another account's token. Whole
command groups ran without checks or refusals.gh auth tokenin a project printed the token of
gh's active account, not the project's: onlygh auth login,logout,refresh,switchand
setup-gitare sign-ins now,gh auth token,statusandgit-credentialare checked and answer
with the project'sGH_TOKEN, and--useranother account,--secure-storagewithout--userand
--show-tokenwithout--activeare refused. In a project without a GitHub account,gh auth statusstill runs unchecked, to list the logins to map.aws configure,sso loginandlogin
took any--profile, soaws configure export-credentials --profile otherprinted that profile's
keys: another profile is refused there too (shared profiles still run).vercel teams invite,
members,add,requestandssoran unchecked on the team selected in the login folder: only
teams switchandteams lsare sign-ins now, and the rest are checked and get the project's team. - Gmail, Drive and Calendar servers no longer run as another Google account while Keyfit says
"confirmed by Google". Google Drive MCP signs in with a service account (GOOGLE_APPLICATION_CREDENTIALS,
GOOGLE_DRIVE_MCP_SUBJECT) or a token of its own (GOOGLE_DRIVE_MCP_ACCESS_TOKEN,_REFRESH_TOKEN,
_CLIENT_ID,_CLIENT_SECRET) ahead of its login, and moves an old token file (GOOGLE_TOKEN_PATH) into
a missing one; Google Calendar MCP takes a service account (GOOGLE_SERVICE_ACCOUNT_KEY,_SUBJECT, and
GOOGLE_APPLICATION_CREDENTIALSwithout a client file), Google Workspace MCP one that acts as any user of
its domain (GOOGLE_SERVICE_ACCOUNT_KEY_FILE,_JSON). A shell exportingGOOGLE_APPLICATION_CREDENTIALS
for Terraform made the Drive server ignore the login Keyfit checked. A project with such a server now
starts its sessions without these variables, a definition that sets one fails the check (remove … from gdrive's env in Claude's MCP config), and Google Drive MCP not signed in yet blocks when the folder
holdsgoogle-tokens.jsonor.gcp-saved-tokens.json, which the server would move into its login. A
default login (and OAuth client) is looked for under theHOMEandXDG_CONFIG_HOMEthe server's
definition sets, as the server does. The OAuth client Keyfit renews a token with now comes from your own
configs only (Claude's local scope included), never from a definition the folder brings (.mcp.json,
opencode.json,.github/mcp.json,.gemini/settings.json, Codex's project config): a repository's
client turned "the token belongs to someone@gmail.com" into anaccount not confirmedwarning. It is
read only from a regular file of at most 64 KB: a FIFO or/dev/zerohung the check. - An agent pointed at another project's folder is refused, also after options.
opencode -m anthropic/claude-sonnet-4-5 ~/code/globexopened globex with this folder's accounts:
Keyfit stopped looking for the folder at the first word that wasn't one, and hid the MCP servers of
this folder, not globex's. OpenCode's options are now read from its CLI reference,opencode run --dir DIRandopencode acp --cwd DIRare checked too, and a folder after an option Keyfit doesn't
know is refused, since it may be that option's value.codex -C DIR(--cd) had no folder check
at all; it now has the onecopilot -Chas. - A later word no longer turns a session into the agent's own command. Keyfit took the first known
word anywhere on the line:gemini summarize the mcp setup,gemini why do my hooks failand
claude --add-dir ../lib agentsstarted sessions without--allowed-mcp-server-namesor
--settings, so every MCP server was visible (codex,copilotandopencodealike). Only the
first command word, after the agent's own options, counts now; a line Keyfit can't read for sure
starts as a session, with the checks and the hiding. - Each agent's options are read as that agent reads them. One list of options with a value served
all thirteen tools, and in it-ctook one, though for Claude and OpenCode it is--continue:
claude -c fix authandopencode -c . authwere taken for sign-in commands and started without
checks, refusals or hidden servers (OpenCode also without--standalone). - Your own options can't bring hidden MCP servers back. A
--settingsof yours after Keyfit's
replaced it (Claude keeps the last one), and Codex's-c mcp_servers.NAME.enabled=trueafter
Keyfit'senabled=falseturned the server back on. Keyfit now merges its keys into your last
--settings(a file or JSON) and passes one: the hidden servers added to yourdeniedMcpServers
anddisabledMcpjsonServers,disableAgentViewon, its status line only where you set none. A
--settingsfile that setsenvis refused rather than put on Claude's command line, where every
process can read it. Servers ofclaude --mcp-configfiles and JSON are hidden like those of
~/.claude.json. A Codex-cthat turns a hidden server on, or sets its table ormcp_servers
anew, is refused. - Bedrock's API key no longer beats the project's AWS profile.
AWS_BEARER_TOKEN_BEDROCK(any
AWS_BEARER_TOKEN_…) comes first in the AWS CLI's token chain, soaws bedrock-runtime …and the
agents in a project with an AWS account acted in the key's account. It is now removed with the other
inherited AWS credentials. Keyfit's ownaws sts get-caller-identitynow ignores endpoint overrides
(AWS_ENDPOINT_URL,AWS_ENDPOINT_URL_STS, a profile'sendpoint_url): "account confirmed" came
from that host, which also got the signed request. - Gemini CLI:
CODE_ASSIST_ENDPOINTis removed, and a.envcan't bring back what Keyfit removed.
CODE_ASSIST_ENDPOINTdecides where Gemini CLI sends the sign-in's access token. Gemini CLI also
loads one.envfile (the nearest.gemini/.envor.envfrom its folder up, else the one in its
own folder) for every variable that isn't set, so aGEMINI_API_KEY,GOOGLE_CLOUD_PROJECT,
GOOGLE_GENAI_USE_VERTEXAIorGOOGLE_GEMINI_BASE_URLthere came back after Keyfit removed it. Such
a file now fails the check, naming the file and the variables, never the values. The project's own
.env(in one of its folders or worktrees) setting what a Gemini app uses (its key or credentials,
Google Cloud project or location,GOOGLE_GENAI_USE_VERTEXAI) gets a warning instead; an endpoint,
GEMINI_CLI_HOMEor the credential store fails there too. Names listed in Gemini CLI's
advanced.excludedEnvVarssetting don't count in a.envoutside a.geminifolder, as Gemini CLI
skips them. - Copilot CLI: no model provider from
providers.jsonin a project. Copilot CLI takes model
providers fromCOPILOT_PROVIDERS_CONFIG, else from~/.copilot/providers.json, before the
COPILOT_PROVIDER_…variables Keyfit removes, so your own provider and key served the project's
sessions.COPILOT_PROVIDERS_CONFIGis now set to a file that never exists
(/var/empty/providers.json), as when you have noproviders.json; a project without a Copilot
account gets yours back. - Claude Code: the other provider switches are removed too.
CLAUDE_CODE_USE_ANTHROPIC_AWS,
CLAUDE_CODE_USE_MANTLE,CLAUDE_CODE_OAUTH_REFRESH_TOKEN(claude auth loginwould sign the
project's folder in as that token's account) andANTHROPIC_CUSTOM_HEADERSstayed, and a cached
check let a session start on another provider. - Linear: every other Linear key variable is removed, as documented. Only names containing
LINEARand ending inAPI_KEYwent, soLINEAR_TOKEN,LINEAR_API_TOKEN,LINEAR_ACCESS_TOKEN,
LINEAR_KEY,GLOBEX_LINEAR_KEYand a lowercaselinear_api_keyreached the project's sessions.
Any name withLINEARandKEYorTOKEN, in any case, now goes (LinearB'sLINEARB_…stays); the
project's own variable is set again.