SkillAgentSearch skills...

hush

Use whenever an agent needs to STORE, GENERATE, or USE a secret such as an API token, signing key, or password. Hush has one hard rule: the agent never sees plaintext, so it never enters chat, transcripts, stdout, logs, the clipboard, or a temp file.

Install / Use

npx skills add royashbrook/hush

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

80/100

Category

Legal

Supported Platforms

Universal

Our assessment of hush

hush scores 80/100 on our quality scale, 187th of 209 Legal skills we index.

Its SKILL.md is 25 KB long, well organised into 16 sections with 7 code examples: a thorough specification that gives an agent plenty to work with.

It has no GitHub stars yet, so there is no community track record; judge it on its content.

Substance
30/30
Structure
20/20
Description
15/15
Adoption
0/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated 12 days ago, so hush is actively maintained.
  • No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
  • Its trust signals score 80/100, with 2 cautions from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

hush compared with similar skills

All 4 of these similar skills score higher than hush; compare them before choosing.

SkillScoreStarsUpdatedFormat
hush (this skill)by royashbrook80012d agoSKILL.md
Agent-Reachby Panniantong100112.7k9d agoCLAUDE.md
headroomby headroomlabs-ai10079.9ktodayCLAUDE.md
Scraplingby D4Vinci100103.9ktodayMCP Server
crawl4aiby unclecode10087.5ktodayMCP Server

Frequently asked questions

How do I install hush?
Run npx skills add royashbrook/hush. The install tabs above show the steps for each supported agent.
Which AI agents does hush work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is hush safe to use?
It declares no license and scores 80/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is hush still maintained?
The repository was last updated 12 days ago, so hush is actively maintained.

name: hush description: "Use whenever an agent needs to STORE, GENERATE, or USE a secret such as an API token, signing key, or password. Hush has one hard rule: the agent never sees plaintext, so it never enters chat, transcripts, stdout, logs, the clipboard, or a temp file. A user-provided value enters once through a hidden prompt; a strong random value can be generated directly into the OS-backed store. Hush later injects it straight into a consumer through an environment variable or stdin, never prints it, and deliberately has no plaintext get command. Trigger on "store this token", "save this key", "add it to the keychain", "generate an operator/signing key", "use the X secret to call Y", or whenever an agent needs a credential to reach a service. macOS, Linux, and Windows backends are built in; the never-print contract is portable beyond them." metadata: version: 1.8.0

hush

For version drift, backup health, upgrade notifications, or scheduler repair, read helpers/MAINTENANCE.md. Start with offline hush doctor. Only --check-updates or an explicitly enabled maintenance check contacts the public registry. Never install notifications or upgrade an installation silently. A loaded job is not a successful backup, and a local iCloud file is not proof of remote upload. Normal secret commands stay quiet.

Optional encrypted backup: npm includes hush-backup and hush-backup-schedule. The scheduler uses macOS launchd, defaults to iCloud Drive, and is opt-in. Follow the README's encrypted-backup section: first ensure a backup key exists and the human keeps a separate recovery copy. Never read the key into agent context. --dry-run checks names and prerequisites without reading values. Do not replace a legacy schedule silently; remove only the old job after confirming migration.

A secret store for AI agents, with one hard rule: the agent never sees the plaintext.

A value never reaches stdout, so it never enters the tool result, the durable transcript, or the cloud. It only ever moves from the store straight into the consumer. There is deliberately no get, because a plain getter is the leak. That single rule is the whole point of this skill, most secret helpers don't have it.

what this is actually for

You're an agent running as the user, with their CLIs already authed (gh, az, wrangler, ...). So you can already set a server-side secret or call a service, the one thing you can't do is see the value. Every usual way to get it is bad: have the user paste it into the chat (now it's in the transcript), drop it in a temp file, or send them off to set it by hand, each one is a context-switch and a leak risk, and half the time the value is never written down, so next time you have to rotate the whole secret.

hush is the single fix. Get the value once, the user pastes into a hidden dialog you pop, or you mint a random one yourself, it lands in the OS keychain, and from then on you inject it into those already-authed commands forever, no more pasting, no more waiting on the user. When they need it back or want to move it elsewhere, it's sitting in their keychain.

It also beats a .env file: nothing lives in the repo, so nothing gets committed by accident, you set secrets server-side straight from the keychain.

the tool

./hush (a single bash script). Make it executable, put it on your PATH or call it directly.

Store backends are auto-detected:

  • macOS → Keychain (security), with a native hidden-field paste dialog for set.
  • Linux → libsecret (secret-tool; apt install libsecret-tools / dnf install libsecret).
  • Windows → a per-user DPAPI-encrypted store via PowerShell (win/hush-backend.ps1), driven from git-bash / WSL. Stored items are DPAPI ciphertext (CurrentUser), useless to any other user.
  • anything else → no built-in backend, but keep the contract and use your platform's secret store (see Other platforms below).

naming convention: one namespace, project-prefixed names

Keep the default hush namespace and prefix each secret's NAME by project, blame-cf-token, lifescored-gemini-key. Two reasons. First, findability: a human searches the keychain for hush once and sees every hush secret across every project. Second, disambiguation: you'll hold several of the same kind of secret (a gemini key for three different projects), so a bare gemini-key is ambiguous, lifescored-gemini-key isn't. The rest of the name is free-form; the project prefix is the part that matters. (The namespace prefixes the stored item, the macOS keychain item is hush:<name>, and list reads names straight from the store, so there's no separate index to drift.)

Do NOT use a per-project HUSH_NS. It's tempting (HUSH_NS=blame), but it breaks the one-search findability above, each project's secrets hide in their own namespace. HUSH_NS exists only for a genuinely separate store: a different agent, or an isolated environment you deliberately want kept out of your normal hush search. That's rare. Per-project separation is the name prefix's job, not the namespace's.

To fix or re-home a name, use hush rename <old> <new> (alias mv), it needs no human. It moves the value inside the store (fetch → store-new → delete-old), never prints it, and never re-asks. So adding a missing prefix is one command: hush rename gemini-api-key lifescored-gemini-key. NEVER rm a secret and re-ask the human to paste a value that's already in the store, that's the exact pointless dance hush exists to kill. If it's already stored, move it; don't beg for it again.

getting a secret INTO the store (the two add-paths)

Pick by where the value comes from:

  1. A value the user holds (a vendor key from a portal, a GitHub PAT). The AGENT runs:

    hush set <name>
    

    and a hidden paste dialog pops on the user's screen (macOS dialog, Linux zenity/kdialog, Windows masked box). The user pastes into it, they never leave the conversation, and the command blocks until they do; then the agent continues. The agent never sees the value. This is the collaborative path: the agent drives it, the user just answers the popup. Don't tell the user to "go run a command and let you know", run hush set <name> yourself and wait for the dialog.

    • re-ask (user pasted the wrong thing, "ask me again for the second token"): the agent just runs hush set <name> again , it overwrites in place. Same for rotating any secret later.
    • scripted/CI: pipe it instead, printf '%s' "$VAL" | hush set <name> (still off argv).
    • dialog won't open on your host: some agent runners have no GUI session, so macOS can't post the dialog (Connection Invalid ... hiservices-xpcservice). hush reports that plainly now (not "cancelled or empty"). Fall back to piping the value, or have the user run hush set <name> from a GUI-attached Terminal. Force a specific method with --gui|--tty|--pipe or HUSH_PROMPT=.
    • the user running hush set in their own terminal is only a far fallback (they can already do that); the whole point is the agent-driven popup so nobody leaves the chat.
  2. The value just needs to be strong + random (an operator key, a signing secret). The agent generates and stores it itself, no human in the loop:

    hush mint <name>            # openssl rand -hex 32 by default; --bytes N to change (alias: gen)
    

autonomy — proceed, or ask the human?

The split falls straight out of the two classes:

  • mint (a strong random value): proceed without asking. When the agent decides it needs an operator key / signing secret / any value that just has to be random, it mints + stores + wires it itself, then tells the human only the name (never the value) and what it's for. Minting is reversible, bounded, and involves no secret the human holds.
  • set (a value the human holds): needs the human. The value comes from outside (a vendor token generated in a portal), so the agent can't proceed alone, it needs the paste. This is the only secret case that should wait on a human.

So a secret that doesn't need the human never blocks on the human.

using a secret (never prints it)

hush run NAME=VAR [N2=V2 ...] -- <cmd>   # fetch into env vars, exec <cmd> (value only in the child)
hush pipe <name> -- <cmd>                # stream the value to <cmd>'s stdin
hush sync lastpass [name ...]            # upsert selected names, or all names when omitted
hush sync lastpass --exclude <name>       # keep a local-only name out of bulk sync; repeatable
hush sync keepass --database <file.kdbx> --db-secret <name> [name ...]
hush sync bitwarden [name ...]           # requires an unlocked BW_SESSION
hush sync azurekv --vault <name> [name ...] # existing az login, changed values only
hush list                                # NAMES only, never values
hush rename <old> <new>                  # move to a new name (value moved INTERNALLY, never re-asked)
hush rm   <name>                         # delete

run and pipe are the whole game. pipe a value straight into an already-authed CLI to set a server-side secret (hush pipe gh-pat -- gh secret set X, hush pipe key -- npx wrangler secret put X); run a command with the value in its environment to call a service (hush run TOKEN=t -- curl ...). The value lives only in that child process , never on disk, never printed.

For a durable LastPass copy, use the built-in one-way sync after the official lpass CLI is logged in:

hush sync lastpass --dry-run                  # validate login, list destinations, read no values
hush sync lastpass                            # all names -> LastPass hush/<name>
hush sync lastpass --group team/secrets foo   # selected name -> team/secrets/foo
hush sync lastpass --exclude local-only       # bulk sync except explicitly local names

The command edits only the LastPass password field. It creates missing entries, updates unique entries, fails on duplicate names, and uses a blocking server sync before reporting success. Values travel on stdin and lpass output is suppressed. Multiline values are refused rather than silently truncated. The official LastPass CLI supports macOS, Linux, and Cygwin, not native PowerShell/Node.

For experimental opt-in macOS sync after reboot, the npm package also installs the Node helper:

hush-lastpass-schedule install --auto-login --email you@example.com --every 6h
hush-lastpass-schedule status
hush-lastpass-schedule remove

The auto-login contract passes deterministic fake-CLI tests but is not live-tested: Homebrew lastpass-cli crashed during out-of-band MFA before vault access, matching upstream issue #719. Accounts unaffected by that bug may work. Setup performs one interactive trusted-device login and stores the master password under hush-lastpass-master-password through hush's hidden prompt. The runner reauthenticates through hush pipe, never uses lpass --plaintext-key, and always excludes that auth secret from sync. A failed setup installs nothing. A revoked or expired LastPass trust grant fails closed and requires interactive setup again. Without --auto-login, the helper schedules sync but requires an already-live lpass session. The helper currently installs a macOS LaunchAgent only.

For an offline-first copy, sync into a KeePassXC KDBX file. The core command works anywhere both hush and keepassxc-cli run:

hush set hush-keepass-master-password
hush sync keepass --database /path/to/hush.kdbx \
  --db-secret hush-keepass-master-password --init
hush sync keepass --database /path/to/hush.kdbx \
  --db-secret hush-keepass-master-password --dry-run

--init refuses overwrite. Omit names to sync every secret except the database-password secret, use positional names for a subset, and repeat --exclude <name> for lo

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars0
CategoryLegal
Updated12d ago
Forks0

Trust signals

80/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

1 medium1 low