vibeaudio 0.16.1 → 0.17.0

package/README.md

@@ -4,7 +4,7 @@
   <img src="docs/og.png?v=2" alt="VibeAudio — Focus music while your AI codes" width="720">
 </p>
 
-[![test](https://github.com/kiril6/vibeaudio/actions/workflows/test.yml/badge.svg)](https://github.com/kiril6/vibeaudio/actions/workflows/test.yml) [![npm](https://img.shields.io/npm/v/vibeaudio)](https://www.npmjs.com/package/vibeaudio) [![downloads](https://img.shields.io/npm/d18m/vibeaudio?label=downloads)](https://npm-stat.com/charts.html?package=vibeaudio) [![downloads/month](https://img.shields.io/npm/dm/vibeaudio)](https://npm-stat.com/charts.html?package=vibeaudio)
+[![test](https://github.com/kiril6/vibeaudio/actions/workflows/test.yml/badge.svg)](https://github.com/kiril6/vibeaudio/actions/workflows/test.yml) [![npm](https://img.shields.io/npm/v/vibeaudio)](https://www.npmjs.com/package/vibeaudio) [![license](https://img.shields.io/npm/l/vibeaudio)](LICENSE) [![node](https://img.shields.io/node/v/vibeaudio)](https://nodejs.org) [![downloads/month](https://img.shields.io/npm/dm/vibeaudio)](https://npm-stat.com/charts.html?package=vibeaudio) [![M8ven Score](https://m8ven.ai/badge/mcp/kiril6/vibeaudio)](https://m8ven.ai/mcp/kiril6/vibeaudio?s=readme)
 
 > **Procedural focus music while your AI coding tools think.**
 > Every project gets its own arrangement. Zero dependencies, zero audio files.
@@ -321,7 +321,7 @@ Every session of an agent is tracked separately, by the session id in its hook p
 
 * **More sessions, more music.** Two sessions working at once plays at least tier 2 and three or more plays tier 3 — the same piece with more layers, arriving at the next loop boundary and easing off as sessions finish. It only ever raises the tier, so it works alongside time escalation and [reactive mode](#reactive-mode-opt-in).
 * **Dialogs and Esc are per session.** A permission dialog in one terminal plays the "your turn" chime but only pauses the music once *every* session is waiting; Esc ends just that session's turn.
-* **Crashed agents can't hold it hostage.** A session that never sent `Stop` is dropped after 15 minutes, the same ceiling the background player stops at.
+* **Crashed agents can't hold it hostage.** A session that goes 15 minutes without any hook (no tool call, no `Stop`) is taken for a crashed agent and dropped. A long turn that keeps working keeps its music.
 
 Sessions with no id in their payload share a single slot, so they behave as one. VibeAudio keeps one stream: per-session genres or several streams mixed together aren't supported.
 
@@ -499,7 +499,7 @@ Changes land at the next loop boundary, so it shifts musically rather than cutti
 * **Backs up first, once.** The first install copies your file alongside as `*.vibeaudio.bak`. Later installs leave it alone — re-copying would overwrite your real pre-VibeAudio config with a copy of VibeAudio's own last install.
 * **Reinstalling updates, never duplicates.** Uninstalling sweeps every supported agent and removes only VibeAudio's own entries.
 * **Refuses rather than clobbers.** Malformed JSON aborts the write; a temporary `npx` checkout is rejected outright, since the hook records an absolute path that npm's cache eviction would later delete.
-* **Can't run away.** The background player is capped at 15 minutes, so a missed stop event can't leave music looping.
+* **Can't run away.** The background player stops once its sessions have been silent for 15 minutes (and after 4 hours at most), so a missed stop event can't leave music looping.
 
 </details>
 
@@ -630,9 +630,11 @@ VIBE_VOLUME = "25"
 Restart the app afterwards — this one is read from the environment the server was launched with, so unlike the saved default it can't change under a running client.
 
 #### Exposed MCP Tools:
-* `vibe_play`: Start procedural focus music (`genre`: `lofi`, `synthwave`, `8bit`, `electronic`, `jazz`, `zen`, `piano`, `drone`, `rain`, `ocean`, `random`; `volume`: `5-100`).
+* `vibe_play`: Start procedural focus music (`genre`: `lofi`, `synthwave`, `8bit`, `electronic`, `jazz`, `zen`, `piano`, `drone`, `rain`, `ocean`, `random`; `volume`: `5-100`; `project_dir`: the workspace's absolute path, optional).
 * `vibe_stop`: Stop music and play the completion chime (`outcome`: `success` or `failure`).
-* `vibe_status`: Return current playback state and active tier.
+* `vibe_status`: Return current playback state and active tier, and which project the arrangement comes from.
+
+**Which project it sounds like.** Hooks and the wrapper run inside your project, so each repo has its own arrangement. An MCP server is started once by the app, so it asks: a client that supports MCP *roots* (Claude Code does) reports its open folder, and any client's model can pass `project_dir`. That project's own settings apply too: a genre saved with `vibe --genre jazz --here` plays for that project over MCP as well. With neither, it uses the folder the app launched the server in, as before; `VIBE_SEED` still overrides all of it. `vibe_status` shows the `project` and its `projectSource` (`project_dir`, `roots`, `cwd` or `VIBE_SEED`).
 
 Playback stops automatically if the desktop client disconnects, and caps out after 15 minutes — which also covers the likelier case of a model that started the music and never called `vibe_stop`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibeaudio",
-  "version": "0.16.1",
+  "version": "0.17.0",
   "description": "Procedural focus music while your AI coding tools (Claude Code, Codex, Cursor, Grok, Gemini, Copilot) think — a different arrangement per project.",
   "bin": {
     "vibeaudio": "bin/vibeaudio.js",

package/src/hooks.js

@@ -143,8 +143,13 @@ function hookTool() {
   setTimeout(commit, 500).unref();
 }
 
-// A lost Stop hook must not leave music looping forever.
-const MAX_DAEMON_MS = 15 * 60 * 1000;
+// A lost Stop hook must not leave music looping forever. This is how long a
+// session may go without a hook before it is taken for a crashed agent; every
+// tool call refreshes it, so a long turn that keeps working keeps its music.
+// VIBE_MAX_DAEMON_MS is internal, for the suite.
+const MAX_DAEMON_MS = Number(process.env.VIBE_MAX_DAEMON_MS) || 15 * 60 * 1000;
+// The daemon's own ceiling, whatever the sessions say: a backstop, not the rule.
+const DAEMON_CEILING_MS = Math.max(MAX_DAEMON_MS, 4 * 60 * 60 * 1000);
 
 /**
  * The agents VibeAudio can wire itself into, and the few things that differ
@@ -519,7 +524,7 @@ function readPid() {
  * so an unverified kill would eventually SIGTERM an unrelated process.
  *
  * Failing closed is the safe direction here: a daemon we decline to kill stops
- * itself at MAX_DAEMON_MS, while killing a stranger's process has no such
+ * itself once no session is left (MAX_DAEMON_MS of silence), while killing a stranger's process has no such
  * ceiling.
  *
  * ponytail: posix only. Windows has no cheap command-line lookup, so the pid
@@ -694,8 +699,8 @@ function writeSession(id, data) {
 
 /**
  * Every session with a turn in flight. One that has not been touched for
- * MAX_DAEMON_MS is a crashed agent - it never sent Stop - and is dropped here,
- * the same ceiling the daemon itself stops at.
+ * MAX_DAEMON_MS is a crashed agent - it never sent Stop - and is dropped here;
+ * the daemon stops once none is left, with DAEMON_CEILING_MS as the backstop.
  */
 function listSessions() {
   let names;
@@ -947,7 +952,7 @@ function runDaemon(genre, volume, { reactive = false, volumeSource = null } = {}
 
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
-  setTimeout(shutdown, MAX_DAEMON_MS);
+  setTimeout(shutdown, DAEMON_CEILING_MS);
 
   setInterval(() => {
     // The pid file names the one daemon that owns the speakers. Two prompts

package/src/mcp.js

@@ -6,7 +6,9 @@
  */
 
 const readline = require("readline");
-const { AudioPlayer, AVAILABLE_GENRES, normalizeVolume, playbackDisabled, musicEnabled, isKnownGenre, loadConfig } = require("./player");
+const path = require("path");
+const { fileURLToPath } = require("url");
+const { AudioPlayer, AVAILABLE_GENRES, normalizeVolume, playbackDisabled, musicEnabled, isKnownGenre, loadConfig, projectSettings } = require("./player");
 const pkg = require("../package.json");
 
 // A desktop client that crashes never sends vibe_stop, so playback needs its
@@ -26,6 +28,64 @@ const annotate = (title, { readOnly, idempotent }) => ({
 
 const OUTCOMES = ["success", "failure"];
 
+/**
+ * Which project this conversation is about. Hooks and the wrapper know it (they
+ * run in it); an MCP server is launched once by the client, in a directory the
+ * client chose, so it has to be told. Two sources, in order:
+ *   1. `project_dir`, an argument the model passes when it has a workspace.
+ *   2. The client's roots (`roots/list`), the protocol's own answer.
+ * With neither, the server's cwd, which is what it always used.
+ * The value is only hashed and matched against keys in our own config file; it
+ * is never opened, so it is not a file-access question - but it comes from the
+ * client, so it must be a plain absolute path of sane length.
+ */
+const MAX_PROJECT_DIR = 1024;
+function cleanProjectDir(value) {
+  if (typeof value !== "string") return null;
+  const v = value.trim();
+  if (!v || v.length > MAX_PROJECT_DIR || v.includes("\0") || !path.isAbsolute(v)) return null;
+  return path.resolve(v);
+}
+
+// A root is a file: URI. Anything else (a remote workspace) is not a path here.
+function rootDirs(roots) {
+  const dirs = [];
+  for (const root of Array.isArray(roots) ? roots : []) {
+    try {
+      const uri = root && typeof root.uri === "string" ? root.uri : "";
+      if (!uri.startsWith("file:")) continue;
+      const dir = cleanProjectDir(fileURLToPath(uri));
+      if (dir) dirs.push(dir);
+    } catch (e) { /* a malformed URI is skipped, not fatal */ }
+  }
+  return dirs;
+}
+
+/** { dir, source }: what to seed from, and why - vibe_status reports the second. */
+function resolveProject(args, session) {
+  const explicit = cleanProjectDir(args && args.project_dir);
+  let dir = null;
+  let source = "cwd";
+  if (explicit) { dir = explicit; source = "project_dir"; }
+  else if (session && session.roots.length) { dir = session.roots[0]; source = "roots"; }
+  // VIBE_SEED outranks every directory (projectSeed reads it); say so.
+  if (process.env.VIBE_SEED && !isNaN(parseInt(process.env.VIBE_SEED, 10))) source = "VIBE_SEED";
+  return { dir, source };
+}
+
+// What the client has told us about itself. `send` writes a request to it.
+function newSession(send = null) {
+  return { supportsRoots: false, roots: [], rootsRequest: null, send, nextId: 1 };
+}
+
+// Ask for the roots. Our own id space ("vibeaudio-roots-N") cannot collide with
+// the client's, and a reply is matched by it.
+function requestRoots(session) {
+  if (!session || !session.supportsRoots || !session.send) return;
+  session.rootsRequest = `vibeaudio-roots-${session.nextId++}`;
+  session.send({ jsonrpc: "2.0", id: session.rootsRequest, method: "roots/list" });
+}
+
 const TOOLS = [
   {
     name: "vibe_play",
@@ -49,6 +109,13 @@ const TOOLS = [
           description: "Playback volume from 5 to 100 (default: 40)",
           minimum: 5,
           maximum: 100
+        },
+        project_dir: {
+          type: "string",
+          description:
+            "Absolute path of the active workspace, if there is one. Omit it when you " +
+            "have no workspace - do not guess a path. It makes this project sound like " +
+            "itself and applies the genre and volume the user saved for it."
         }
       }
     }
@@ -90,10 +157,22 @@ const TOOLS = [
   }
 ];
 
-function handleMessage(player, msg) {
+function handleMessage(player, msg, session = null) {
   const { id, method, params } = msg;
 
+  // The client's answer to our roots/list: it has a result, not a method.
+  if (method === undefined && session && id !== undefined && id === session.rootsRequest) {
+    session.rootsRequest = null;
+    session.roots = rootDirs(msg.result && msg.result.roots);
+    return null;
+  }
+  // Any other response is an answer to something we asked, not a request: it
+  // gets no reply (a "method not found" for it would be sent to the client).
+  if (method === undefined && (msg.result !== undefined || msg.error !== undefined)) return null;
+
   if (method === "initialize") {
+    // roots is a client capability: only a client that declares it can be asked.
+    if (session) session.supportsRoots = Boolean(params && params.capabilities && params.capabilities.roots);
     return {
       jsonrpc: "2.0",
       id,
@@ -117,13 +196,22 @@ function handleMessage(player, msg) {
           "and you are ready to hand back a result.\n" +
           "Do not use it for quick answers - starting and stopping music around a " +
           "one-second reply is worse than silence. Leave the genre and volume alone " +
-          "unless the user asks; they are the user's preference, not yours."
+          "unless the user asks; they are the user's preference, not yours.\n" +
+          "If you have a workspace, pass its absolute path as vibe_play's project_dir so " +
+          "this project sounds like itself; omit it when you have none."
       }
     };
   }
 
   if (method === "notifications/initialized") {
-    // Client acknowledgment - no response needed
+    // Client acknowledgment - no response needed, but this is the first moment
+    // a request of ours is allowed, so ask which project it has open.
+    requestRoots(session);
+    return null;
+  }
+
+  if (method === "notifications/roots/list_changed") {
+    requestRoots(session);
     return null;
   }
 
@@ -153,10 +241,16 @@ function handleMessage(player, msg) {
       // saved file here is what makes `vibe --genre jazz` mean jazz in a
       // desktop client too, rather than only in the terminal.
       const saved = loadConfig();
+      const project = resolveProject(args, session);
+      const dir = project.dir || process.cwd();
+      // What `vibe --here` saved for this project sits between the environment
+      // and the machine-wide default, as it does for the CLI and the hooks.
+      const here = projectSettings(saved, dir);
+      const setting = (key) => (here[key] !== undefined ? here[key] : saved[key]);
       // The argument comes from the client: only a string counts. A number or
       // object here used to reach `.toLowerCase()` and fail the whole call.
       const asked = typeof args.genre === "string" ? args.genre.trim() : "";
-      const requested = String(asked || process.env.VIBE_GENRE || saved.genre || "lofi");
+      const requested = String(asked || process.env.VIBE_GENRE || setting("genre") || "lofi");
       // An unknown genre already fell back to lofi inside the generator, but
       // player.genre kept the name nobody implements - so the model told the
       // user it was playing something that does not exist.
@@ -165,10 +259,10 @@ function handleMessage(player, msg) {
       // as the CLI, so a mistyped VIBE_VOLUME falls back instead of reaching
       // the player as NaN.
       const volume = normalizeVolume(args.volume,
-        normalizeVolume(process.env.VIBE_VOLUME, normalizeVolume(saved.volume, 0.4)));
+        normalizeVolume(process.env.VIBE_VOLUME, normalizeVolume(setting("volume"), 0.4)));
 
       // A deliberate setting, like a mute: report it as one, and start nothing.
-      if (!musicEnabled()) {
+      if (!musicEnabled(process.env, saved, dir)) {
         return {
           jsonrpc: "2.0",
           id,
@@ -176,7 +270,7 @@ function handleMessage(player, msg) {
         };
       }
 
-      const started = player.start(genre, volume, { maxDurationMs: MAX_PLAYBACK_MS });
+      const started = player.start(genre, volume, { maxDurationMs: MAX_PLAYBACK_MS, project: project.dir });
       // start() returns false for three unrelated reasons, and the model
       // relays whatever we say here to the user. Reporting a deliberate mute
       // as a missing audio player sends them debugging their sound stack.
@@ -232,6 +326,7 @@ function handleMessage(player, msg) {
     }
 
     if (name === "vibe_status") {
+      const statusProject = resolveProject({}, session);
       return {
         jsonrpc: "2.0",
         id,
@@ -244,7 +339,13 @@ function handleMessage(player, msg) {
                 // Without this, "isPlaying: false" while muted reads as a bug
                 // worth investigating rather than a choice the user made.
                 muted: playbackDisabled(),
-                musicOff: !musicEnabled(),
+                musicOff: !musicEnabled(process.env, loadConfig(), statusProject.dir || process.cwd()),
+                // Which project the next vibe_play seeds from and how we learned
+                // it (project_dir | roots | cwd | VIBE_SEED), and, while music
+                // plays, the one it is playing for.
+                project: statusProject.dir || process.cwd(),
+                projectSource: statusProject.source,
+                playingProject: player.isPlaying ? (player.projectDir || process.cwd()) : null,
                 genre: player.genre,
                 currentTier: player.currentTier,
                 uptimeMs: player.isPlaying ? Date.now() - player.startTime : 0
@@ -281,6 +382,8 @@ function handleMessage(player, msg) {
 
 function startMcpServer() {
   const player = new AudioPlayer();
+  const send = (message) => process.stdout.write(JSON.stringify(message) + "\n");
+  const session = newSession(send);
 
   // In stdio MCP mode, stderr is used for logging, stdout is strictly reserved for JSON-RPC
   process.stderr.write(`[vibeaudio] MCP Server running on stdio (v${pkg.version})\n`);
@@ -306,7 +409,7 @@ function startMcpServer() {
 
     let response;
     try {
-      response = handleMessage(player, msg);
+      response = handleMessage(player, msg, session);
     } catch (err) {
       process.stderr.write(`[vibeaudio] Handler error: ${err.message}\n`);
       // A request (one with an id) must always get a reply. Swallowing the
@@ -316,7 +419,7 @@ function startMcpServer() {
       }
     }
 
-    if (response) process.stdout.write(JSON.stringify(response) + "\n");
+    if (response) send(response);
   });
 
   // Client disconnected - never leave audio looping behind.
@@ -336,4 +439,4 @@ function startMcpServer() {
   });
 }
 
-module.exports = { startMcpServer, handleMessage, TOOLS };
+module.exports = { startMcpServer, handleMessage, TOOLS, newSession, resolveProject, cleanProjectDir, rootDirs };

package/src/player.js

@@ -438,8 +438,8 @@ function playbackDisabled() {
  * Env beats this directory's saved value beats the global one; a flag is
  * resolved by parseArgs() and handed to whoever acts on it.
  */
-function musicEnabled(env = process.env, config = loadConfig()) {
-  const raw = env.VIBE_MUSIC ?? projectSettings(config).music ?? config.music ?? "on";
+function musicEnabled(env = process.env, config = loadConfig(), cwd = process.cwd()) {
+  const raw = env.VIBE_MUSIC ?? projectSettings(config, cwd).music ?? config.music ?? "on";
   return !["off", "0", "false", "no"].includes(String(raw).trim().toLowerCase());
 }
 
@@ -751,6 +751,7 @@ class AudioPlayer {
     this.genre = "lofi";
     this.volume = 0.42;
     this.seed = projectSeed();
+    this.projectDir = null; // Set when a client names the project (MCP); null means the cwd.
     this.intensity = null;
     this.minTier = null;
     this.tension = null;
@@ -764,12 +765,13 @@ class AudioPlayer {
    * Returns true if playback actually started. Restarts when called with
    * different settings while playing, so a genre switch is not silently dropped.
    */
-  start(genre = "lofi", volume = 0.42, { maxDurationMs = null, intensity = null, minTier = null, tension = null } = {}) {
+  start(genre = "lofi", volume = 0.42, { maxDurationMs = null, intensity = null, minTier = null, tension = null, project = null } = {}) {
     const resolved = resolveGenre(genre);
     const targetVolume = Math.max(0.05, Math.min(1.0, volume));
 
     if (this.isPlaying) {
-      if (resolved === this.genre && targetVolume === this.volume) return false;
+      // A different project is a different arrangement, so it restarts too.
+      if (resolved === this.genre && targetVolume === this.volume && (project || null) === this.projectDir) return false;
       this.stop({ playChime: false });
     }
 
@@ -784,7 +786,8 @@ class AudioPlayer {
     this.startTime = Date.now();
     this.genre = resolved;
     this.volume = targetVolume;
-    this.seed = projectSeed();
+    this.projectDir = project || null;
+    this.seed = projectSeed(project || process.cwd());
     this.bar = 0; // Every run opens on the project's own bar.
     this.intensity = intensity;
     this.minTier = minTier;