claude-music 1.1.0 → 1.1.1

package/dist/__tests__/shutdown.test.js

@@ -0,0 +1,35 @@
+import { describe, it, expect, vi } from "vitest";
+import { EventEmitter } from "node:events";
+import { installShutdownHooks } from "../server.js";
+describe("installShutdownHooks", () => {
+    it("stops the daemon when the stdio pipe closes (Claude Code exits)", () => {
+        const stop = vi.fn();
+        const exit = vi.fn();
+        const stdin = new EventEmitter();
+        installShutdownHooks(stop, { stdin, exit });
+        expect(stop).not.toHaveBeenCalled();
+        // Parent closed the pipe → stdin hits EOF.
+        stdin.emit("end");
+        expect(stop).toHaveBeenCalledOnce();
+        expect(exit).toHaveBeenCalledWith(0);
+    });
+    it("stops at most once even if several signals arrive", () => {
+        const stop = vi.fn();
+        const exit = vi.fn();
+        const stdin = new EventEmitter();
+        installShutdownHooks(stop, { stdin, exit });
+        stdin.emit("end");
+        stdin.emit("close");
+        expect(stop).toHaveBeenCalledOnce();
+    });
+    it("survives a throwing stop() without rethrowing", () => {
+        const stop = vi.fn(() => {
+            throw new Error("daemon already gone");
+        });
+        const exit = vi.fn();
+        const stdin = new EventEmitter();
+        installShutdownHooks(stop, { stdin, exit });
+        expect(() => stdin.emit("end")).not.toThrow();
+        expect(exit).toHaveBeenCalledWith(0);
+    });
+});

package/dist/server.js

@@ -96,6 +96,41 @@ export function stopDaemon() {
     }
     fs.rmSync(SOCKET_PATH, { force: true });
 }
+/**
+ * Tie the daemon's lifetime to this MCP server process. The daemon is spawned
+ * detached so it survives across tool calls, which also means nothing stops it
+ * when Claude Code shuts us down. We bridge that gap here: when the host closes
+ * our stdio pipe (the normal "Claude Code exited" path — stdin hits EOF) or
+ * sends us a termination signal, stop the daemon so the music doesn't outlive
+ * the session.
+ */
+export function installShutdownHooks(stop, opts = {}) {
+    const stdin = opts.stdin ?? process.stdin;
+    const exit = opts.exit ?? ((code) => process.exit(code));
+    let done = false;
+    const cleanup = (shouldExit) => {
+        if (done)
+            return;
+        done = true;
+        try {
+            stop();
+        }
+        catch {
+            /* best effort — we're on the way out regardless */
+        }
+        if (shouldExit)
+            exit(0);
+    };
+    // Parent (Claude Code) closed the stdio pipe → EOF reaches us as 'end'/'close'.
+    stdin.on("end", () => cleanup(true));
+    stdin.on("close", () => cleanup(true));
+    // Host asked us to terminate.
+    for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+        process.on(sig, () => cleanup(true));
+    }
+    // Last-ditch sync safety net for any other exit path.
+    process.on("exit", () => cleanup(false));
+}
 /** Build and connect the MCP stdio server. Invoked by `claude-music mcp`. */
 export async function runServer() {
     const server = new McpServer({ name: "mrt2-mcp", version: "1.0.0" });
@@ -142,4 +177,6 @@ export async function runServer() {
     });
     const transport = new StdioServerTransport();
     await server.connect(transport);
+    // connect() puts stdin in flowing mode, so 'end' fires reliably on EOF.
+    installShutdownHooks(stopDaemon);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-music",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Live AI background music for Claude Code, scored in real time by Claude itself (Magenta RealTime 2 on Apple Silicon).",
   "type": "module",
   "bin": {