Skip to content
Back to search

feedme

MarketplaceWorks with Claude CodeGitHub

feedme, a Claude Code plugin that plays a sound (and calls your webhooks) when Claude is waiting for you.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/thekoma--feedme/badge.svg)](/listings/thekoma--feedme)

HTML

<a href="/listings/thekoma--feedme"><img src="/api/listings/thekoma--feedme/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Inside Claude Code:

/plugin marketplace add thekoma/feedme
/plugin install feedme@feedme

Or from a shell:

claude plugin marketplace add thekoma/feedme
claude plugin install feedme@feedme

Start a new session, then try `/feedme:play` to hear the active set.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 15 lines
  1. {
  2. "name": "feedme",
  3. "description": "feedme, a Claude Code plugin that plays a sound (and calls your webhooks) when Claude is waiting for you.",
  4. "owner": {
  5. "name": "thekoma",
  6. "url": "https://github.com/thekoma"
  7. },
  8. "plugins": [
  9. {
  10. "name": "feedme",
  11. "source": "./",
  12. "description": "Plays a sound (and optionally calls your webhooks) when Claude has been waiting for you for a while."
  13. }
  14. ]
  15. }
README.md · README · 324 lines
  1. # feedme
  2. A Claude Code plugin that makes noise when Claude is waiting for you.
  3. Claude finishes a turn, you are on another window, and nothing happens for
  4. ten minutes. With feedme, if you have not answered after a few seconds, your
  5. computer plays a sound (by default Audrey II shouting *"Feed me!"*). It can
  6. also call your webhooks or run your scripts, for example to blink a lamp
  7. through Home Assistant.
  8. - Sound sets you can switch with one command, and add your own by dropping files in a folder
  9. - Webhooks with optional headers, and plain scripts, run when the alert fires
  10. - On/off switch and a configurable delay
  11. - Bash only, no runtime to install. macOS out of the box, Linux best-effort
  12. ## How it works
  13. ```text
  14. Claude stops ──► Stop hook arms a timer for this session
  15. │
  16. ├─ you type, a tool runs, or the session ends ──► timer cancelled
  17. │
  18. └─ timeout passes with no answer ──► sound + your actions
  19. ```
  20. Each Claude Code session has its own timer, so several terminals do not get in
  21. each other's way.
  22. ## Install
  23. Inside Claude Code:
  24. ```text
  25. /plugin marketplace add thekoma/feedme
  26. /plugin install feedme@feedme
  27. ```
  28. Or from a shell:
  29. ```sh
  30. claude plugin marketplace add thekoma/feedme
  31. claude plugin install feedme@feedme
  32. ```
  33. Start a new session, then try `/feedme:play` to hear the active set.
  34. ## Commands
  35. | Command | What it does |
  36. |---------|--------------|
  37. | `/feedme:on` | Turn the alert on |
  38. | `/feedme:off` | Turn the alert off |
  39. | `/feedme:status` | Show on/off, timeout, sound set, audio player and actions |
  40. | `/feedme:timeout [seconds]` | Show or set how long Claude waits before the alert (1 to 86400, default 10) |
  41. | `/feedme:list` | List the sound sets; `*` marks the active one |
  42. | `/feedme:set <name>` | Choose the sound set |
  43. | `/feedme:play [name]` | Play a sound now, from the active set or the one named |
  44. | `/feedme:hook add <name> '<url>' ['Header: value'...]` | Call a webhook when the alert fires |
  45. | `/feedme:hook list` | List webhooks and scripts, with secrets masked |
  46. | `/feedme:hook test [name]` | Run the actions now and show the result |
  47. | `/feedme:hook rm <name>` | Remove a webhook |
  48. The same commands work from a terminal with the script itself, for example
  49. `~/.claude/plugins/marketplaces/feedme/scripts/feedme.sh status`.
  50. ## Configuration
  51. Settings live in `~/.config/feedme/config` (or `$XDG_CONFIG_HOME/feedme/config`),
  52. outside the plugin folder. They survive plugin updates and are shared by every
  53. Claude Code profile on the machine, including ones started with
  54. `CLAUDE_CONFIG_DIR`.
  55. ```ini
  56. enabled=1
  57. timeout=10
  58. set=feedme
  59. ```
  60. Use the commands above rather than editing the file by hand; if you do edit it,
  61. an invalid value falls back to its default.
  62. Environment variables, mostly for testing and special setups:
  63. | Variable | Effect |
  64. |----------|--------|
  65. | `FEEDME_DELAY` | Overrides `timeout` for the sessions that see it |
  66. | `FEEDME_PLAYER` | Path of the audio player to use instead of auto-detection |
  67. | `FEEDME_CONFIG_DIR` | Use another config folder |
  68. | `FEEDME_ACTION_TIMEOUT` | Seconds before a hanging script is killed (default 10) |
  69. | `FEEDME_TRACE` | File where every `arm`, `cancel` and `fire` is logged, for debugging |
  70. ## Sound sets
  71. | Set | Sounds | Source |
  72. |-----|--------|--------|
  73. | `feedme` (default) | Audrey II asking to be fed | *Little Shop of Horrors* (1986) |
  74. | `8bit` | pipe dive, game over, power-up, jump | Original chiptune, generated by `tools/make-8bit.py` |
  75. | `sitcom` | laughs, applause, "ooh", "aww", sigh | CC0 clips from Freesound |
  76. | `cartoon` | boing, spring, slide whistle, bonk, pop | CC0 clips from Freesound |
  77. When the alert fires, feedme picks one sound at random from the active set.
  78. Every set has a `CREDITS.md` with the source and license of each file.
  79. ### Use your own sounds
  80. A set is just a folder of audio files. Create one in `~/.config/feedme/sounds/`:
  81. ```sh
  82. mkdir -p ~/.config/feedme/sounds/mine
  83. cp ~/Downloads/*.wav ~/.config/feedme/sounds/mine/
  84. ```
  85. Then run `/feedme:list` to see it and `/feedme:set mine` to use it.
  86. To **replace** a bundled set, create a folder with the same name: a set in
  87. `~/.config/feedme/sounds/feedme/` is used instead of the bundled `feedme`.
  88. Remove the folder to get the original back.
  89. Set names may contain letters, digits, `.`, `_` and `-`. Files the audio player
  90. cannot decode are ignored:
  91. | Player | Platform | Formats |
  92. |--------|----------|---------|
  93. | `afplay` | macOS | wav, aif, aiff, mp3, m4a, caf |
  94. | `paplay`, `pw-play` | Linux | wav, aif, aiff, flac, ogg |
  95. | `aplay` | Linux | wav |
  96. | `ffplay`, `mpv` | any | all of the above |
  97. WAV works everywhere. To convert and trim a clip, and match the loudness of the
  98. bundled sounds, use the import tool that ships with the plugin (it needs
  99. `ffmpeg`):
  100. ```sh
  101. ~/.claude/plugins/marketplaces/feedme/tools/import-sound.sh \
  102. input.mp3 ~/.config/feedme/sounds/mine/clip.wav [start-seconds] [duration-seconds]
  103. ```
  104. ### Share a set
  105. Pull requests with new sets are welcome. Add a folder under `sounds/` with the
  106. WAV files and a `CREDITS.md` listing source, author and license for each one.
  107. Only include sounds you are allowed to redistribute (CC0, public domain, or
  108. your own recordings).
  109. ## Actions: webhooks and scripts
  110. Actions run at the same moment as the sound. They live in
  111. `~/.config/feedme/hooks.d/`, and you can have as many as you like.
  112. ### Webhooks
  113. ```text
  114. /feedme:hook add lamp 'https://homeassistant.local:8123/api/webhook/<your-webhook-id>'
  115. /feedme:hook add notify 'https://example.com/hooks/claude' 'Authorization: Bearer <token>' 'X-Source: feedme'
  116. /feedme:hook test
  117. ```
  118. feedme sends a `POST` with this JSON body:
  119. ```json
  120. {"event": "feedme", "set": "feedme", "session_id": "…", "cwd": "/path/of/the/project"}
  121. ```
  122. Things to know:
  123. - **Single-quote the URL and every header.** The arguments go through a shell,
  124. so an unquoted `&`, `;` or `#` cuts the URL, and `$` gets expanded. After
  125. `add`, feedme prints the URL length so you can spot a cut-off URL.
  126. - **What you type stays in the conversation history.** If a URL or header holds
  127. a secret you would rather keep out of the transcript, write the file yourself:
  128. ```sh
  129. mkdir -p ~/.config/feedme/hooks.d && chmod 700 ~/.config/feedme/hooks.d
  130. cat > ~/.config/feedme/hooks.d/lamp.webhook <<'EOF'
  131. url=https://homeassistant.local:8123/api/webhook/<your-webhook-id>
  132. header=Authorization: Bearer <token>
  133. EOF
  134. chmod 600 ~/.config/feedme/hooks.d/lamp.webhook
  135. ```
  136. - Webhook files are created readable only by you, `/feedme:hook list` masks the
  137. URL path and header values, and curl receives URL and headers on stdin so
  138. they never show up in `ps`.
  139. - Each request times out after 5 seconds.
  140. ### Scripts
  141. Any executable file in `~/.config/feedme/hooks.d/` runs when the alert fires,
  142. with these variables:
  143. | Variable | Value |
  144. |----------|-------|
  145. | `FEEDME_SET` | Active sound set |
  146. | `FEEDME_SOUND` | Path of the sound being played |
  147. | `FEEDME_SESSION_ID` | Claude Code session id |
  148. | `FEEDME_CWD` | Working directory of the session |
  149. For example, a desktop notification on macOS:
  150. ```sh
  151. cat > ~/.config/feedme/hooks.d/notify <<'EOF'
  152. #!/bin/bash
  153. osascript -e "display notification \"Waiting in ${FEEDME_CWD##*/}\" with title \"Claude\""
  154. EOF
  155. chmod +x ~/.config/feedme/hooks.d/notify
  156. ```
  157. On Linux, use `notify-send "Claude" "Waiting in ${FEEDME_CWD##*/}"` instead.
  158. A script that runs longer than 10 seconds is stopped together with the
  159. processes it started: first with SIGTERM, then with SIGKILL two seconds later. Files that are not executable are ignored, so you can keep
  160. notes in the same folder.
  161. ## Alerting on more Claude Code events
  162. The plugin arms the alert when Claude stops (`Stop`) and cancels it when you
  163. send a prompt, a tool starts, or the session ends. You can attach the same
  164. script to other events from your own `settings.json`. The script is in the
  165. marketplace copy of this repo, at
  166. `${CLAUDE_CONFIG_DIR:-$HOME/.claude}/plugins/marketplaces/feedme/scripts/feedme.sh`.
  167. For example, to also be called when Claude is waiting for a permission
  168. answer:
  169. ```json
  170. {
  171. "hooks": {
  172. "Notification": [
  173. {
  174. "matcher": "permission_prompt",
  175. "hooks": [
  176. { "type": "command", "command": "\"${CLAUDE_CONFIG_DIR:-$HOME/.claude}/plugins/marketplaces/feedme/scripts/feedme.sh\" arm", "timeout": 5 }
  177. ]
  178. }
  179. ],
  180. "PostToolUse": [
  181. {
  182. "hooks": [
  183. { "type": "command", "command": "\"${CLAUDE_CONFIG_DIR:-$HOME/.claude}/plugins/marketplaces/feedme/scripts/feedme.sh\" cancel", "timeout": 5 }
  184. ]
  185. }
  186. ],
  187. "PostToolUseFailure": [
  188. {
  189. "hooks": [
  190. { "type": "command", "command": "\"${CLAUDE_CONFIG_DIR:-$HOME/.claude}/plugins/marketplaces/feedme/scripts/feedme.sh\" cancel", "timeout": 5 }
  191. ]
  192. }
  193. ]
  194. }
  195. }
  196. ```
  197. Claude Code sends `permission_prompt` once a permission dialog has been open
  198. for a few seconds. The `PostToolUse` and `PostToolUseFailure` entries matter:
  199. the plugin cancels the alert before a tool starts, which happens before the
  200. permission dialog, and nothing else cancels it once you approve. Without them,
  201. a long command you approve could let the alert fire while Claude is still
  202. working. Keep these hooks in shell form (a `command` string, no `args`) so the
  203. `${CLAUDE_CONFIG_DIR:-$HOME/.claude}` part gets expanded.
  204. `arm` and `cancel` read the hook JSON from stdin, always exit 0 and never print
  205. anything, so they are safe on any event.
  206. To change the default events for everyone, fork the repo, edit
  207. `hooks/hooks.json`, and install your fork instead.
  208. ## Troubleshooting
  209. - **No sound:** run `/feedme:status`. It shows whether feedme is on, the
  210. timeout, the active set and the audio player found. `/feedme:play` plays a
  211. sound immediately.
  212. - **The sound plays twice:** you probably still have hand-written feedme hooks
  213. in `settings.json` from before the plugin. Remove them.
  214. - **Nothing happens at all:** start Claude with `FEEDME_TRACE=/tmp/feedme.trace`
  215. and check that the file gets `arm` and `cancel` lines. If it stays empty, the
  216. plugin is not enabled: check `/plugin`.
  217. - **Silence it for a while:** `/feedme:off`, then `/feedme:on`.
  218. ## Platforms
  219. - **macOS:** tested; uses `afplay`, which ships with the system.
  220. - **Linux:** best-effort; needs one of `paplay`, `pw-play`, `aplay`, `ffplay`
  221. or `mpv`, and `curl` for webhooks.
  222. - **Windows:** not supported (WSL may work with a Linux player).
  223. `jq` is used when present to read the hook input; without it a simpler parser
  224. takes over.
  225. ## Uninstall
  226. ```sh
  227. claude plugin uninstall feedme@feedme
  228. claude plugin marketplace remove feedme
  229. rm -rf ~/.config/feedme # settings, your sound sets and actions
  230. ```
  231. ## Development
  232. ```sh
  233. /bin/bash tests/run.sh # test suite, under the oldest bash we support (3.2)
  234. shellcheck -x scripts/feedme.sh scripts/lib/*.sh tests/run.sh tools/*.sh
  235. claude plugin validate .
  236. claude --plugin-dir . # try your working copy
  237. ```
  238. Layout:
  239. | Path | Purpose |
  240. |------|---------|
  241. | `scripts/feedme.sh` | Entry point for hooks and commands |
  242. | `scripts/lib/config.sh` | Settings file |
  243. | `scripts/lib/sounds.sh` | Sound sets and audio players |
  244. | `scripts/lib/alert.sh` | arm, cancel and fire |
  245. | `scripts/lib/actions.sh` | Webhooks and scripts |
  246. | `hooks/hooks.json` | Claude Code events the plugin listens to |
  247. | `skills/*/SKILL.md` | The `/feedme:*` commands |
  248. | `sounds/<set>/` | Bundled sound sets |
  249. | `tools/` | Sound generation and import |
  250. ## License
  251. Code: [MIT](LICENSE). Sounds: see each set's `CREDITS.md`. The `feedme` clips
  252. come from *Little Shop of Horrors* (1986) and belong to their rights holders;
  253. they will be removed on request.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.