---
title: "Install the client"
description: "Install the client, set it up, and connect an agent through the skill."
canonical: "https://www.superstables.com/docs/client"
last-updated: 2026-11-19
---

# Install the client

The Superstables client is a command, `superstables`, and the `superstables` agent skill
that guides an agent through it. Start with [Budget](https://www.superstables.com/docs/client/budget.md), where the owner
grants an on-chain budget once, or [Single purchase](https://www.superstables.com/docs/client/buy-once.md), where the owner approves
each purchase (Single purchase on superstables.com, or Single purchase on your machine: `pay` on a page on this machine). Mainnet by default. `--testnet` uses test USDC, USDG or pathUSD instead (USDG on Robinhood Chain Testnet, pathUSD on Tempo Moderato).

## What you need

- Node 22 or newer.
- Linux or macOS. On Windows, use WSL: `superstables budget` refuses to run on native Windows.
- Network access to sellers and chain RPCs (testnet RPCs with `--testnet`), and to the approval site when using approvals on superstables.com.
- For **local approvals**, an owner browser wallet that can reach the client's `127.0.0.1` page:
  an EVM wallet for EVM/Tempo, or a Solana wallet for a Solana budget. On the same machine, use
  a browser extension wallet. Over SSH, forward the approval link's port first:
  `ssh -L PORT:127.0.0.1:PORT user@host`. No superstables.com account is needed.
- For **approvals on superstables.com**, the owner can use a wallet on another device. They need a
  superstables.com account. They sign in with an Ethereum or Solana wallet or an email address. An account
  admin links wallets on the account page: an Ethereum wallet for EVM chains and Tempo, or a Solana wallet
  for Solana. The owner approves with the linked wallet. An ordinary remote browser without a compatible
  wallet cannot sign. Choose [Budget on superstables.com](https://www.superstables.com/docs/client/budget.md#approve-on-superstablescom-instead)
  or [Single purchase on superstables.com](https://www.superstables.com/docs/client/buy-once.md#hosted-buy-once-superstables-budget-buy-once).

These instructions describe **client 1.4.5** and require that release build. Install it from npm
as `@superstables/client`, or use the released commit and skill from
[GitHub Releases](https://github.com/superstables/superstables/releases).
The CLI/skill runs on your own machine or server,
even with approvals on superstables.com. EVM `recover` still needs a reachable local approval page and the
agent key on that runtime. Test-token and gas requirements belong to the chosen
[Budget](https://www.superstables.com/docs/client/budget.md#what-you-need) or [Single purchase](https://www.superstables.com/docs/client/buy-once.md) flow.

The client runs on your machine and contacts sellers, the facilitators that settle x402 payments,
chain RPCs (testnet RPCs with `--testnet`), the Superstables index and, when switched on, the demo catalogue on superstables.com and, in an
interactive `superstables doctor`, the npm registry (`SUPERSTABLES_NO_UPDATE_CHECK=1` turns that off).

## Install

Pick one. All of them run the same commands on the same state, in `~/.superstables`.

**The plugin.** In Claude Code or Codex, the [plugin](https://github.com/superstables/superstables/blob/62945c06020746945a512bac3d72baa039d66c65/README.md#the-plugin) adds the
Superstables skill and connector. It uses the connector where a tool is available, and runs this
client with `npx` for operations that need your machine or when connector tools are missing or you
decline to connect. Its install steps are in the README and on superstables.com's Get started page.
In Claude (claude.ai, Claude desktop and mobile), the plugin zip is uploaded in Customize › Plugins.

**The connector.** A chat app (Claude, ChatGPT or Grok Bot) adds `https://mcp.superstables.com`
without the plugin. It can find services, request a purchase you approve on superstables.com, list or
cancel the purchase requests it made, read budgets, give you the link to revoke one, and remove an agent
that has no spending permission. It cannot run the client, so it declines budget set-up,
grants, funding, buying under a budget and `pay`. The chat shows each approval link with a line
naming the account's wallets by their last four characters; if that is not your account, don't
approve. Grok Bot takes the same URL: ask the bot in chat to add a remote MCP server with it, then
sign in. The sign-in page should name the app Grok Bot; if it names another app, stop. In our testing
on testnet, the Grok Bot desktop app signed in, found services and completed single purchases on Base
Sepolia. Other chains, reading an existing budget and phone use are not tested yet. The steps for each app are at
[superstables.com/docs/chat-apps](https://www.superstables.com/docs/chat-apps), and
[the README](https://github.com/superstables/superstables/blob/62945c06020746945a512bac3d72baa039d66c65/README.md#or-the-connector) says what Grok Bot can and can't do.

**The agent skill, from Get started.** The one-line prompt on superstables.com's Get started page
has the agent install the plugin in Claude Code and Codex, and in other agents that run commands
download the skill zip, check its SHA-256 checksum and install it. The skill bundles
the whole CLI; [The agent skill](#the-agent-skill-with-the-whole-cli-bundled) below installs it by
hand.

The examples on these pages write the command as `superstables`. Installing from npm with `-g`, or
a checkout with `npm link`, puts that command on your PATH. For a git install pinned to a commit,
use `npx --no superstables …` in the installation folder, as shown below.

Don't type `npx superstables` to run the client. Where npx doesn't find this client's command, it
downloads whatever package the npm registry has under the name `superstables`, which is not this
client. The client's package is `@superstables/client`.

### From npm

```bash
npm install -g @superstables/client@1.4.5
superstables --version
```

This installs the `superstables` command, `superstables budget` included. The npm package holds
the command, not the agent skill: to connect an agent, also install the skill, as described in
[Set up your agent app](#set-up-your-agent-app).

### From a checkout

To run the client from its sources, for example to work on it, replace `<commit>` with the full
commit hash of the 1.4.5 release:

```bash
git clone https://github.com/superstables/superstables.git
cd superstables
git checkout --detach <commit>
npm ci
npm run build
npm link
superstables --version
```

`npm link` puts the checkout's `superstables` command on your PATH, so every command in these
docs works as written. Without it, run `node <checkout>/dist/cli/main.js …`, or
`npx --no superstables …` at the repository root. Keep the `--no`: when npx doesn't find this
checkout's command, it downloads whatever package the npm registry has under that name, and
`--no` makes it stop instead.

### With npm, from git

In any folder, with `<commit>` replaced by the full commit hash of the 1.4.5 release (its
page on GitHub names the commit):

```bash
npm install github:superstables/superstables#<commit>
npx --no superstables --version
```

npm clones the repository at that commit, installs its development packages, builds the client
on your machine with them and installs the result, `superstables budget` included. That build
runs the repository's build scripts and the TypeScript compiler on your machine. Name a commit hash: without one, npm installs whatever the default branch holds
at that moment, and a branch or tag name can later point somewhere else.
Run it as `npx --no superstables …` in that folder, or as `node_modules/.bin/superstables …`.

### The agent skill, with the whole CLI bundled

`npm run skill` in a checkout builds `build/superstables-skill-<version>.zip`, and
the 1.4.5 release uses that versioned zip. Unzip it into your agent's skills folder, `~/.claude/skills/` for
Claude Code or `~/.agents/skills/` for Codex. It unpacks to `superstables/`, and needs
only Node:

```bash
node ~/.claude/skills/superstables/scripts/superstables.mjs --version
```

Use that path wherever these pages say `superstables`. `scripts/THIRD_PARTY_NOTICES.txt` lists
the bundled packages and their licences.

`superstables --version` names the build that is running.

### Checking a build against its commit

The npm package and the skill zip each carry a CycloneDX 1.5 software bill of materials:
`dist/sbom.cdx.json` in the package, `scripts/sbom.cdx.json` in the skill. It lists every third-party
package the client installs or bundles, with its version, licence, the npm tarball it came from and
that tarball's SHA-512. Most of the budget's Solana and Tempo code is bundled, so `npm audit` in a
project that installs the client does not see it; give the SBOM to a scanner that reads CycloneDX to
check those packages too.

A build is dated with its commit's time, not the time it ran, and ships no source maps, so two
builds of the same commit give the same files. To check a release against its source, build its
commit the way the release does:

```bash
git clone https://github.com/superstables/superstables.git
cd superstables
git checkout --detach <commit>
node scripts/repro-check.mjs
```

It builds the commit twice from `git archive` exports, with `npm ci`, `npm run skill` and
`npm pack`, and prints the SHA-256 of the skill zip, the npm tarball and the tarball's uncompressed
contents. Compare the zip's checksum with `sha256sum` of the zip from GitHub Releases. For npm,
download the published tarball with `npm pack @superstables/client@<version>` and compare
`gzip -dc <file>.tgz | sha256sum` with the uncompressed figure: different npm versions compress the
same files differently.

The tarball records file modes, and they follow the umask of the shell that builds it: under the
common defaults (`022` and `002`) every file is packed as `0644`, but under `077` the same commit
gives a different tarball. `repro-check` sets its own umask for its builds. If you build the
release yourself some other way, do it under `umask 022`.

## Set up

For `pay`, the owner runs `setup` once; Single purchase on superstables.com and Budget don't need it. It creates `~/.superstables`, writes a starting spend
policy (`policy.yaml`) with the limits written out, by default 0.05 per payment and 1 per UTC day, counted across USDC, USDG and pathUSD one for one. The owner edits a value to change it, or writes `null` to remove it. `setup` also prints how the owner
approves payments. In the default browser mode it creates no key: the owner's key stays in their wallet. Running it
again keeps the existing policy.

```bash
superstables setup
superstables doctor
```

`doctor` checks the machine, one line per item: that the home directory, the payment records and the policy are in place,
which account last connected, that the approval port is free, and that the demo service, the
index and the facilitators answer:

```
  client version           1.4.5
  home                     /home/you/.superstables

✓ home directory           /home/you/.superstables (writable)
✓ payment records          /home/you/.superstables/records: every line reads
✓ spend policy             /home/you/.superstables/policy.yaml: up to 0.05 USDC per payment, 1 USDC per day
✓ browser wallet           no account connected yet: MetaMask connects when the first approval link opens
✓ approval page            http://127.0.0.1:23817 is free; the agent serves the page itself
✓ demo service             https://www.superstables.com/api/demo/market asks for payment (HTTP 402)
✓ Superstables index       https://www.superstables.com/api/v1/services answered HTTP 200
✓ facilitator.x402.rs      settles exact payments on Base Sepolia (testnet)
✓ facilitator.payai.network settles exact payments on Base Sepolia (testnet)
✓ x402.org                 settles exact payments on Base Sepolia (testnet)

Everything this machine needs is in place.
```

Not having connected an account yet is fine and is not a failure. A budget has its own setup:
see [Budget](https://www.superstables.com/docs/client/budget.md).

In browser mode there is no approval process to start. When a payment needs approval,
`superstables pay` serves the approval page on `127.0.0.1:<port>` and prints an approval link of the
form `http://127.0.0.1:<port>/approve/<id>`. The port is this install's own, chosen once between
20000 and 29999 and kept in `approve-port` in your Superstables folder. If another payment is already
waiting on it, the page takes a free port instead, and the approval link names that port.

## Set up your agent app

The plugin brings its own skill, so a plugin install needs nothing here. The skill is called `superstables` in the plugin (`/superstables:superstables` in Claude Code, `$superstables` in Codex). Without the plugin, an agent uses the client through the same skill from the skill zip (`/superstables` in Claude Code, `$superstables` in Codex), and a shell. The skill guides
it through finding a service, pricing it and both ways to pay, with their safety rules. Use the
skill zip installed above, or link the `plugin/skills/superstables/` folder from a checkout into
your agent's skills folder. Keep `SKILL.md`, `references/` and `agents/openai.yaml` together.

### Which build is running

After an update, `superstables --version` names the build that is running, and `superstables doctor`
prints it with the home directory it uses (`~/.superstables` unless you changed it). In the skill,
`scripts/VERSION.json` names the version and commit.

Releases are tagged `v<version>` on GitHub, with the release notes taken from
[../CHANGELOG.md](https://github.com/superstables/superstables/blob/62945c06020746945a512bac3d72baa039d66c65/CHANGELOG.md).

## The paid service

The demo buys from a small x402 service Superstables hosts at
`https://www.superstables.com/api/demo/market` (`HOSTED_DEMO_SERVICE_URL` in
`src/core/discovery.ts`), so there is something to buy without anyone running a seller.

The seller is in this repository too, and `superstables demo-service` runs it, which is worth
doing to watch the seller's side of a payment. `SUPERSTABLES_DEMO_SERVICE_URL` then points the
client at that instance, or at any other one:

```bash
superstables demo-service --pay-to 0xYourSellerAddress
SUPERSTABLES_DEMO_SERVICE_URL="http://127.0.0.1:4402/v1/market" superstables find
```

A real x402 seller on `127.0.0.1:4402`. It answers `GET /v1/market?asset=BTC` with HTTP 402 and
its terms, verifies and settles the credential you send through a public facilitator, and only
then returns the data. 0.01 USDC per request by default.

| Option | Meaning |
| --- | --- |
| `--port <n>` | Listen somewhere other than 4402. Set `SUPERSTABLES_DEMO_SERVICE_URL` to match |
| `--pay-to <0x…>` | Where the money goes. Defaults to `SUPERSTABLES_DEMO_PAY_TO` |
| `--price <decimal>` | USDC per request. Default 0.01 |

Point `--pay-to` at an address you control. With no `--pay-to` and no environment variable it
generates a throwaway address, prints it and warns you: anything paid there is unrecoverable.

## The local wallet, for a machine with no browser

The second signer keeps a key in a file and serves its own approval page, protected by the owner
secret. It is the fallback, not the default.

```bash
superstables --wallet local setup          # creates ~/.superstables/wallet/key, prints the address
superstables --wallet local wallet serve   # leave it running
```

Setup asks for a passphrase, twice, and stores the key encrypted with it; `wallet serve` asks for it
each time it starts. Without a terminal there is nobody to ask, so setup creates no key: run
`superstables wallet init --no-passphrase` to store it unencrypted (testnet only), and
`superstables wallet encrypt` later to protect it.

Budget agent keys (`superstables budget setup --key-store os-keychain`, on `evm` and `solana`) can live in the
operating system's keychain instead of a file. Linux needs `secret-tool`, from the `libsecret-tools` package, and a
running secret service; macOS has `security` built in. Without the tool, setup refuses and writes nothing. A locked
keychain makes `buy`, `grant`, `fund-agent`, `recover` and owner requests on chains approved on superstables.com
refuse until it is unlocked (a local `revoke` still works). The key file then holds only the address.

It binds `127.0.0.1:4411` and opens the approval page in your browser, already signed in. It
does that through a launcher file only you can read, in `~/Superstables-wallet-open/`, and
prints its path in case the browser does not open; the file, and the folder once empty, are
deleted when the wallet stops. It never prints the owner secret itself. The page sends the secret to the wallet process in an Authorization header, so the owner
can approve. The page does not keep the secret: after a reload, run `superstables --wallet local wallet open`
to open it signed in again.

Over SSH, or with a browser that cannot open the launcher file, forward the port
(`ssh -L 4411:127.0.0.1:4411 user@host`), open `http://127.0.0.1:4411/` and paste the owner
secret, which `cat ~/.superstables/wallet/owner-secret` prints on the wallet's machine. Keep the
secret to yourself: it approves payments.

| Option | Meaning |
| --- | --- |
| `--port <n>` | Listen somewhere other than 4411. The agent is not affected: it reaches the wallet on its private socket |
| `--tcp` | Also serve the agent's routes on the TCP port, for an agent that reaches this wallet over SSH forwarding; set `SUPERSTABLES_WALLET_URL` on the agent's side. Any process on this machine that has the agent token can then use them |
| `--approval-timeout <seconds>` | How long a request waits for you. Default 120 |
| `--no-open` | Do not open a browser; print where the page and the launcher are |

Every other command needs `--wallet local` too, or `SUPERSTABLES_WALLET=local` in the
environment the agent's commands run in.
Fund the address it prints with test USDC (USDG on Robinhood Chain Testnet) on the EVM chain you
pay on: on SKALE Base Sepolia, Base Sepolia test USDC bridged over the SKALE bridge; on Robinhood
Chain Testnet, test USDG from [https://faucet.paxos.com](https://faucet.paxos.com); on the other EVM chains, test USDC from
[https://faucet.circle.com](https://faucet.circle.com) with the payment's chain selected. The local wallet signs on the EVM
chains only (Tempo and Solana payments are approved in a browser wallet on the approval page). Stopping the wallet is the off switch: with no
wallet, `pay` fails with "the wallet is not running", and nothing can be signed.

## Environment variables

| Variable | Default | What it does |
| --- | --- | --- |
| `SUPERSTABLES_HOME` | `~/.superstables` | Where the policy, the records and the remembered account live |
| `SUPERSTABLES_WALLET` | `browser` | Who signs: `browser` (a browser wallet) or `local` (the local wallet process) |
| `SUPERSTABLES_APPROVE_PORT` | unset: this install's own port (20000-29999, kept in `approve-port`), or a free port when it is busy | Fixes the approval page's port, browser mode. A fixed port that is busy fails at once, without asking the owner or using up the quote. `0` picks a free port |
| `SUPERSTABLES_POLICY` | `$SUPERSTABLES_HOME/policy.yaml` | Read the policy from somewhere else. `~/.superstables/policy.yaml` still applies when it exists |
| `SUPERSTABLES_WALLET_URL` | unset: the wallet's socket, `wallet/agent.sock` | The local wallet over TCP, for one started with `wallet serve --tcp` |
| `SUPERSTABLES_WALLET_AGENT_TOKEN` | read from `wallet/agent-token` | The agent's bearer token for the local wallet, when it is not on this filesystem |
| `SUPERSTABLES_DEMO_SERVICE_URL` | `https://www.superstables.com/api/demo/market` | Where the built-in catalogue says the paid service is |
| `SUPERSTABLES_DEMO_PAY_TO` | none | Default recipient for `demo-service` |
| `SUPERSTABLES_DEMO_HOST` | `127.0.0.1` | Which interface `demo-service` binds |
| `SUPERSTABLES_RPC_URL` | `https://sepolia.base.org` | Base Sepolia RPC, used to read the USDC balance and to check a settlement on chain (https, or http on this machine). Unset: the owner's RPC, else this default |
| `SUPERSTABLES_TEMPO_RPC` | `https://rpc.moderato.tempo.xyz` | Tempo Moderato RPC, used to check a `pay` on chain and to search for one whose transaction the page did not report (https, or http on this machine). The budget's tempo rail reads it too; for owner actions only when the owner's settings name it. Unset: the owner's RPC, else this default |
| `SUPERSTABLES_SOLANA_RPC` | `https://api.devnet.solana.com` | Solana devnet RPC, used to check a `pay` on chain (https, or http on this machine). The budget's solana rail reads it too; for owner actions only when the owner's settings name it. Unset: the owner's RPC, else this default |
| `SUPERSTABLES_INDEX_URL` | `https://www.superstables.com/api/v1/services` | The service index `find` reads. Point it at another index that answers the same API, or set it to `off` to list the built-in catalogue only |
| `SUPERSTABLES_DEMO_SERVICES` | unset (off) | `on` includes Superstables' testnet services from the catalogue on superstables.com in discovery. Most return prepared sample output, carry `mock: true` and come after the listings not marked simulated; the market data service returns live prices. `find --demo` does the same for one search; leave it off to list no simulated services |
| `SUPERSTABLES_CATALOGUE_URL` | `https://www.superstables.com/api/demo/catalogue` | Where those services are published, read only when `SUPERSTABLES_DEMO_SERVICES` is on. Point it at another deployment, or set it to `off` |
| `SUPERSTABLES_SITE` | `https://www.superstables.com` | The site `setup --hosted` uses when `--site` is not given; `budget find` and `buy-once` use it before the site a setup on superstables.com recorded. `setup --hosted` records its site as `SITE=` in the chain's public file, and later owner commands on that chain use that one and refuse a different `--site`. The owner's approvals happen on this site. It counts only when the owner's settings allow it (`superstables owner settings`); `www.superstables.com` always does |
| `SUPERSTABLES_TESTNET` | unset (mainnet) | `1` or `true` makes the run testnet-only, as `--testnet` does; unset, empty, `0` or `false` keeps the default, mainnet, and any other value is an error that names the variable and refuses every chain. Each mainnet must still pass the chain gate's checks ([Mainnet](https://www.superstables.com/docs/client/security.md#mainnet)) |
| `SUPERSTABLES_ALLOW_SITE` | unset | No longer read; a warning is printed when it is set. Use `superstables owner settings site <origin>` |
| `SUPERSTABLES_DOCTOR_OFFLINE` | unset | `1` makes `doctor` skip every check that needs network access |
| `SUPERSTABLES_NO_UPDATE_CHECK` | unset | `1` skips the interactive doctor check for a newer client release |

`SUPERSTABLES_HOME` is read when state is first touched, so set it before starting a process
rather than during one. The CLI's `--home <dir>` sets it for you, and `--wallet <mode>` sets
`SUPERSTABLES_WALLET` the same way.

### Owner settings

The approval site and the RPCs that owner actions trust are not set by an agent's environment. They live in
`~/.superstables/owner/settings.json`, in the home directory the operating system records for your account, so
every `SUPERSTABLES_HOME` of that account shares one file. With no file, the built-in defaults apply:
`https://www.superstables.com` and each chain's public RPC.

```
superstables owner settings show
superstables owner settings site <origin>        # or: site --clear
superstables owner settings allow-staging on
superstables owner settings allow-loopback site|rpc|sellers on
superstables owner settings rpc <chain> <url...> [--own-node] [--quorum N]
```

`show` is read only. Every change runs only in your own terminal and asks you to type `yes`. `allow-loopback` is for
development machines: it lets a site, an RPC variable or a seller on this computer count as yours. RPC URLs are never
printed whole, because they can carry an access key. A file that exists but cannot be used (not valid, a symlink,
writable by others) stops the commands that need it, and `superstables owner settings show` says why.

## Ports

| Port | What binds it | When | Bound to |
| --- | --- | --- | --- |
| this install's port (20000-29999), or a free port when it is busy | the approval page, inside the agent's own process | browser mode, from the first payment | `127.0.0.1` |
| 4411 | the local wallet's owner page (the agent reaches the wallet on `wallet/agent.sock`, not a port) | `--wallet local` only | `127.0.0.1` |
| 4402 | the demo service | only if you run the seller yourself; the one on superstables.com needs no port | `127.0.0.1` |

With these defaults, none is reachable from another machine; `SUPERSTABLES_DEMO_HOST` can bind
the demo service to another interface. If a port is busy, move it with the matching
variable or `--port`. The approval page moves by itself: a busy approval port usually means another
payment is waiting there for its owner, so leave that process running.

## Update or remove

Use the route you installed. Start a new agent session after changing a plugin or skill.

- **Claude Code, Git marketplace:** update the marketplace with `claude plugin marketplace update superstables`, then run `claude plugin update superstables@superstables`. Remove the plugin with `claude plugin uninstall superstables@superstables`.
- **Codex, Git marketplace:** run `codex plugin marketplace upgrade superstables`, then `codex plugin remove superstables@superstables` and `codex plugin add superstables@superstables` to reinstall it. Remove it with `codex plugin remove superstables@superstables`.
- **Claude Code or Codex, downloaded plugin zip:** download and verify the new release zip, unpack it to a new folder, for Codex first run `codex plugin remove superstables@superstables`, then remove the old marketplace with `claude plugin marketplace remove superstables` or `codex plugin marketplace remove superstables`. Follow the [plugin install steps](https://github.com/superstables/superstables/blob/62945c06020746945a512bac3d72baa039d66c65/README.md#the-plugin) using the new folder. Removing a marketplace can also remove its installed plugins.
- **Claude:** download and verify the new Claude plugin zip, delete the installed plugin from Customize › Plugins, then upload the new zip there. To remove it, delete it there and disconnect its connector separately in Customize › Connectors. See [Claude’s plugin guide](https://support.claude.com/en/articles/13837440-use-plugins-in-claude).
- **Skill zip:** download and verify the new skill zip, then replace the `superstables` folder in your agent's skills directory. Remove that folder to uninstall the skill.
- **npm CLI:** update with `npm install -g @superstables/client@latest`; remove with `npm uninstall -g @superstables/client`. A checkout or git install must instead be updated at its source or installed again at the new release commit.
- **Chat connectors:** end the connection on your [account page](https://www.superstables.com/account). In Claude, disconnect it in Customize › Connectors; in ChatGPT, choose Actions › Disconnect; in Grok Bot, choose Remove account. Ending app access does not revoke agent budgets; revoke them separately.

Interactive `superstables doctor` checks `https://registry.npmjs.org/@superstables%2fclient/latest` for a newer client and prints a notice when it finds one. The request tells npm your IP address. Set `SUPERSTABLES_NO_UPDATE_CHECK=1` to disable it; `SUPERSTABLES_DOCTOR_OFFLINE=1` also skips it. The check is silent on failure, does not run for JSON output or purchases, and is not run when stdout is not a terminal.

## Uninstalling

Revoke each budget first: deleting an agent key does not end its allowance on chain. Run
`superstables budget revoke --rail <rail> --chain <chain> --wait` for each budget's rail and chain,
have the owner approve it, then check that `superstables budget status --rail <rail> --chain <chain>`
says `revoked: true`. For a named Tempo key, add `--agent <label>` to both.

For each chain you set up with `setup --hosted`, also remove the agent on your account page on that
site: that is what removes it from your account, and no command does it. Revoking on chain stops the
spending but leaves the agent on your account.

Before deleting files, resolve uncertain outcomes using [Records](https://www.superstables.com/docs/client/records.md#check-an-unresolved-outcome).
Keep the journals and keys needed for those checks. For stranded EVM USDC, see
[recovery](https://www.superstables.com/docs/client/budget.md#recovery-and-ending-use); revoke alone does not return it.

Then delete the skill folder if you installed it, and delete `~/.superstables`
(or your `SUPERSTABLES_HOME`). If you installed from npm, run
`npm uninstall -g @superstables/client`. If you linked a checkout with `npm link`, remove the
global link with `npm unlink --global @superstables/client`; this removes the linked command,
without downloading a package. If you installed from git in a separate installation folder, remove
that installation after preserving any records you still need.

With `pay` in the default browser mode, that directory holds no key, and your funds in your wallet are
not affected. It can hold keys in two cases, and deleting it makes any funds those keys hold
unreachable. They are testnet funds, but check before you delete:

- `wallet/key`, with `--wallet local`;
- `keys/budget/`, the agent keys of `superstables budget`, which can hold gas the owner sent with
  `fund-agent`.
