Skip to content
Back to search

vibeclaude-local

MarketplaceWorks with Claude CodeGitHub

A port of opencode-buttplugio to Claude Code written by Opus 5.5.

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/transkatgirl--vibeclaude/badge.svg)](/listings/transkatgirl--vibeclaude)

HTML

<a href="/listings/transkatgirl--vibeclaude"><img src="/api/listings/transkatgirl--vibeclaude/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.

git clone https://github.com/transkatgirl/vibeclaude.git ~/.claude/vibeclaude
cd ~/.claude/vibeclaude && npm install

Then either load it for one session:

claude --plugin-dir ~/.claude/vibeclaude

or add it permanently from inside Claude Code:

/plugin marketplace add ~/.claude/vibeclaude
/plugin install vibeclaude@vibeclaude-local

Restart Claude Code. The plugin loads at session start.

The daemon runs from the directory Claude Code loads the plugin from, and needs its `node_modules` there. A plugin installed from a marketplace is loaded from Claude Code's own copy, which may not have them (one cloned from a git repository never does). If a toast says `the "buttplug" npm package is missing`, run `npm install` in the directory it names.

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 · 11 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "vibeclaude-local",
  3. "owner": { "name": "transkatgirl" },
  4. "plugins": [
  5. {
  6. "name": "vibeclaude",
  7. "source": "./",
  8. "description": "Claude Code lifecycle events → Intiface Central vibration feedback"
  9. }
  10. ]
  11. }
README.md · README · 245 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <p align="center"><img src="logo.svg" width="160" alt="VibeClaude logo"></p>
  2. # VibeClaude
  3. *Vibe coding, taken entirely too literally.*
  4. Use an "extra controller" from [Intiface Central](https://intiface.com/central) and
  5. [buttplug.io](https://buttplug.io) to connect every Claude Code action deeply with your
  6. body. A port of [opencode-buttplugio](https://github.com/FurryR/opencode-buttplugio) to
  7. Claude Code's function hooks.
  8. ```
  9. Claude Code ──hooks module──HTTP──▶ daemon ──WebSocket──▶ Intiface Central ──BLE──▶ you
  10. ```
  11. ## Requirements
  12. - Claude Code with function-hooks plugin support (an early-access API; built against 2.1.291)
  13. - Node.js 22+, as `node` on your `PATH` (the `buttplug` client does not run on older versions)
  14. - Intiface Central with its WebSocket server running (default `ws://127.0.0.1:12345`)
  15. - A little desire
  16. - A comfortable, private setting
  17. - Some lubricant (optional, but strongly recommended)
  18. - A vibration-capable "controller", paired in Intiface Central
  19. ## Install
  20. ```bash
  21. git clone https://github.com/transkatgirl/vibeclaude.git ~/.claude/vibeclaude
  22. cd ~/.claude/vibeclaude && npm install
  23. ```
  24. Then either load it for one session:
  25. ```bash
  26. claude --plugin-dir ~/.claude/vibeclaude
  27. ```
  28. or add it permanently from inside Claude Code:
  29. ```
  30. /plugin marketplace add ~/.claude/vibeclaude
  31. /plugin install vibeclaude@vibeclaude-local
  32. ```
  33. Restart Claude Code. The plugin loads at session start.
  34. The daemon runs from the directory Claude Code loads the plugin from, and needs its
  35. `node_modules` there. A plugin installed from a marketplace is loaded from Claude Code's own
  36. copy, which may not have them (one cloned from a git repository never does). If a toast says
  37. `the "buttplug" npm package is missing`, run `npm install` in the directory it names.
  38. ## Use
  39. 1. Start Intiface Central and press the server start button.
  40. 2. In Claude Code run `/intiface`.
  41. 3. Select a vibration-capable device from the scan results.
  42. 4. Get comfortable, connect with your device, and slowly adjust to the feeling of becoming
  43. one with it.
  44. 5. Start enjoying your coding session.
  45. | Command | Description |
  46. |---|---|
  47. | `/intiface` | Connect to Intiface, scan, and select a device. |
  48. | `/intiface-connect` | Connect to the configured Intiface server and go back to the device you last selected, if it is there. |
  49. | `/intiface-disconnect` | Disconnect and stop all device output. |
  50. | `/intiface-intensity [0.0-1.0]` | Set how strong everything is, as a multiplier from `0` to `1`. Without a number, says what it is set to. |
  51. The commands run in the plugin itself: they start no model turn, use no tokens, and leave
  52. nothing in the conversation. All four also work while a turn is running.
  53. `/intiface` opens a dialog that says what it is doing (Connecting, Scanning) and then lists
  54. the devices that can vibrate, the selected one marked Connected. Move with the arrows or
  55. Tab, pick with Enter or a click, leave with Escape.
  56. Nothing plays until a device has been selected. Exactly one device is driven at a time:
  57. it has your undivided attention, and you have its.
  58. When the first session starts, the plugin connects to Intiface and restores the previously
  59. selected device when it is available. If Intiface was not running then, each Claude Code
  60. started later tries again, unless you disconnected with `/intiface-disconnect`. When the
  61. last session ends, it stops the device and disconnects.
  62. Notices such as "Restored …" or "Connection to Intiface was lost" appear as toasts, in
  63. every open session, as they happen. If the connection is lost the device is deselected;
  64. reconnect with `/intiface`. A device that drops off on its own is selected again when it
  65. comes back.
  66. You can do something else while a turn runs. You do not need to watch the screen: bodily
  67. pleasure and the haze in your mind will tell you whether the task is complete.
  68. ## What you feel
  69. Every pattern is a constant intensity for a fixed time. Within a conversation only one
  70. plays at once: the most recent event wins, so your body always knows what Claude is doing
  71. right now.
  72. | What happens | Pattern |
  73. |---|---|
  74. | Thinking and text, as they stream | A 70ms pulse per piece, 0.35–0.8, rising with average output speed (saturates at 40 chars/s). A faster model finishes sooner. You know what I mean. |
  75. | A response arrives whole, with nothing of it streamed (thinking included) | One 150ms pulse at 0.4 |
  76. | The model starts writing a tool call | One 120ms pulse at 0.5 |
  77. | The model starts writing an `Edit`/`Write`/`MultiEdit`/`NotebookEdit` | No pulse: a steady hold at 0.3 for as long as the edit is being written and applied, until it finishes, fails, or asks for permission |
  78. | A tool call succeeds | One slow, deep 180ms pulse at 0.7 |
  79. | A tool call fails, is denied, or is rejected at its prompt | One sudden, sharp 280ms pulse at 1.0 |
  80. | A todo/task tool completes an item | One pulse at 0.8, replaced at once by the tool's own success pulse |
  81. | A subagent's run ends | The pulse of a tool call succeeding; of one failing if the run was interrupted or failed |
  82. | A permission prompt is waiting | Three 90ms pulses at 0.85, a pause, repeating until answered. Thinking and text are not felt meanwhile |
  83. | The turn ends | Three 100ms pulses at 1.0 |
  84. | The turn is interrupted or fails | Everything of the turn's stops, then the three pulses of a turn ending |
  85. | The session ends | Everything stops |
  86. Every Claude Code session you have open drives the device, each keeping track of its own
  87. tool calls, permission prompts and todos. When more than one is playing you feel the
  88. strongest of them, and when that one stops the device goes back to whatever the others are
  89. still playing: a pulse from one session does not cut short an edit hold in another, and
  90. ending or interrupting one session stops only its own output.
  91. A subagent is felt like the conversation that started it: its thinking and text as they
  92. stream, a response that arrives whole, its tool calls, its permission prompts and its
  93. todos. It is mixed with that conversation, and with any other subagent at work, the way
  94. another session is: you feel the strongest of them, and a pulse from one does not cut
  95. short an edit hold, or the pulses of the turn ending, in another. The end of a subagent's
  96. run is not the end of the turn: it is felt as a tool call's result, and for a subagent in
  97. the foreground it lands together with the result of the call that started it. One that
  98. is interrupted with its turn is felt as the turn ending, whose three pulses take the place
  99. of its result. One in the background plays on after the turn has ended or been
  100. interrupted, until its own run does; ending the session stops them all. While a permission
  101. prompt waits, thinking and text are held back in the whole of its session, so that
  102. whatever else is still streaming does not fill the pauses that give the prompt its rhythm;
  103. tool calls and edit holds still come through.
  104. Too much, or saving yourself for later? `/intiface-intensity 0.5` halves everything. The
  105. intensity is one multiplier for the whole daemon, applied last: every session and subagent
  106. plays its patterns as the table has them, the strongest is picked, and that is what gets
  107. multiplied. It starts at `1.0` (every pattern as written), takes effect at once, whatever
  108. is playing included, and is remembered until you change it. At `0` nothing is felt;
  109. anything above it still is, since a faint level rounds up to the device's weakest step,
  110. never down to nothing.
  111. Turn completion, permission requests, interruptions, completed todos... you no longer need
  112. a separate notification plugin. Now you can feel it all with your body, as though Claude
  113. Code has become one with you.
  114. Three things are approximations, because of what Claude Code tells a plugin:
  115. - **Thinking.** Claude Code hands a plugin thinking's text only where it is shown to
  116. someone. Where it is withheld (a headless `claude -p` run is one such place), thinking is
  117. not felt.
  118. - **Answering a permission prompt.** Claude Code draws the prompt itself and does not say
  119. when it was answered. The pattern stops when the tool that asked finishes or fails, or
  120. when you reject it. So after you approve a call that takes a while, the pattern goes on
  121. until the call is done. The one earlier sign is the run-in-background hint Claude Code
  122. draws under a long-running command a moment after it starts: that stops the pattern
  123. too, but only in the terminal, and where several commands share one hint, only for the
  124. first of them. A subagent's prompt also stops when the subagent's run ends. Other tool
  125. calls running alongside do not silence it.
  126. - **Tool output.** Nothing reports a command's output as it is printed, so it is not
  127. felt: a tool's result is its one pulse.
  128. Worn out? Output stops automatically when you switch devices, end the session, disconnect,
  129. lose the Intiface connection, or the daemon exits. After intense "coding," a rest may be
  130. in order.
  131. ## Configure
  132. Claude Code asks for the plugin's options when you enable it; change them later under
  133. `/plugin` → manage.
  134. | Option | Default | Description |
  135. |---|---|---|
  136. | `wsAddress` | `ws://127.0.0.1:12345` | Intiface Central WebSocket address. |
  137. A new address takes effect when the daemon next starts: end your sessions, or run
  138. `node daemon/daemon.mjs stop` and let the next event start it again.
  139. The selected device, the intensity and `daemon.log` are kept in `~/.config/vibeclaude`. If TCP
  140. port 12350 is taken on your machine, a `config.json` there containing `{ "port": 12351 }`
  141. moves the daemon.
  142. ## How it works
  143. `hooks/register.tsx` is a hooks module: it runs inside Claude Code, where it sees the
  144. model's response as it streams (`turn.step`), each tool call from start to finish
  145. (`tool.call`), permission checks, subagents being started (`agent.spawn`), and turns and
  146. sessions beginning and ending, in the conversation and in each subagent's own loop. It reduces
  147. each to a tiny event (sizes and identifiers, not text) and posts them, in order, to the
  148. daemon on `127.0.0.1:12350`. It never makes the model's stream wait for a request. It also
  149. registers the slash commands, draws the `/intiface` dialog and shows the daemon's notices
  150. as toasts.
  151. A hooks module has no Node, so it cannot run the `buttplug` client or hold a WebSocket.
  152. `daemon/daemon.mjs` holds everything else: the connection to Intiface Central through the official `buttplug`
  153. client, the selected device, and the vibration engine and its handlers, which are the
  154. original plugin's. A device answers slower than a response streams, so it is sent the
  155. latest level asked of it, never a backlog. The first session starts it; it exits when the last session ends
  156. (`/clear` and resuming hand over to the next session instead). It also watches the Claude
  157. Code process behind each session, and ends the session of one that went away without saying
  158. so. Only where it cannot tell which process that is does it fall back to exiting after 30
  159. minutes without activity. It can be driven from a shell too:
  160. | Command | What it does |
  161. |---|---|
  162. | `node daemon/daemon.mjs scan` | Connect, scan 3s, list vibration-capable devices |
  163. | `node daemon/daemon.mjs select <index>` | Select a device from the scan |
  164. | `node daemon/daemon.mjs connect` / `disconnect` | Connect to / disconnect from Intiface |
  165. | `node daemon/daemon.mjs intensity [value]` | Set the intensity multiplier (`0` to `1`); without a value, print it |
  166. | `node daemon/daemon.mjs start` | Make sure a daemon is running; print its port |
  167. | `node daemon/daemon.mjs status` | Is a daemon answering? |
  168. | `node daemon/daemon.mjs stop` | Stop all output and exit the daemon |
  169. | `node daemon/daemon.mjs` | Run in the foreground |
  170. These use `~/.config/vibeclaude` and the default address unless you pass
  171. `--home <dir>` and `--ws <address>`. `VIBECLAUDE_DEBUG=1 node daemon/daemon.mjs` logs every
  172. event as it arrives.
  173. ## Try it without hardware
  174. No "controller" on hand? A mock will take its place and stoically print what it would have
  175. felt:
  176. ```bash
  177. node test/mock-intiface.mjs 12345 # fake Intiface Central with one device, prints motor level
  178. npm test # the daemon end to end against its own mock, then the hooks module
  179. ```
  180. ## Privacy
  181. The plugin sends device commands only to the configured Intiface address on your machine.
  182. The daemon listens on loopback only and takes JSON requests addressed to `127.0.0.1` or
  183. `localhost`, which a page in your browser cannot send it.
  184. There is no telemetry. Nobody will know you used it to push your KPIs far beyond your coworkers'.
  185. ## Not included (yet)
  186. - Live tool output, and the exact moment a permission prompt is answered: see above.
  187. - Patterns that scale with the size of an edit. The original's code for this is never
  188. reached, so there is nothing to port.
  189. - Codex CLI: its `notify` hook only reports turn completion and approval requests, so a port
  190. would get the completion and permission pulses but not the per-tool or streaming feedback.
  191. - Non-vibration outputs (rotate, oscillate, linear). Pull requests welcome.
  192. ## License
  193. This project is licensed under the [MIT License](LICENSE). Buttplug and Intiface are
  194. trademarks of Nonpolynomial Labs, LLC.

Ratings and comments

Sign in to rate this skill.

Sign in

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