claude-music 1.0.0

package/dist/__tests__/download.test.js

@@ -0,0 +1,25 @@
+import { describe, it, expect } from "vitest";
+import { MODEL_FILES } from "../download.js";
+import { MODEL_FILE, RESOURCES_DIR, MAGENTA_HOME } from "../paths.js";
+describe("MODEL_FILES", () => {
+    it("includes the compiled small model and its state", () => {
+        expect(MODEL_FILES).toContain("models/mrt2_small/mrt2_small.mlxfn");
+        expect(MODEL_FILES).toContain("models/mrt2_small/mrt2_small_state.safetensors");
+    });
+    it("includes all musiccoca and spectrostream resources", () => {
+        const musiccoca = MODEL_FILES.filter((f) => f.startsWith("resources/musiccoca/"));
+        const spectrostream = MODEL_FILES.filter((f) => f.startsWith("resources/spectrostream/"));
+        expect(musiccoca).toHaveLength(6);
+        expect(spectrostream).toHaveLength(4);
+    });
+    it("has no duplicate entries", () => {
+        expect(new Set(MODEL_FILES).size).toBe(MODEL_FILES.length);
+    });
+});
+describe("paths", () => {
+    it("derives the model + resources paths from the magenta home", () => {
+        expect(MODEL_FILE.startsWith(MAGENTA_HOME)).toBe(true);
+        expect(RESOURCES_DIR.startsWith(MAGENTA_HOME)).toBe(true);
+        expect(MODEL_FILE.endsWith("models/mrt2_small/mrt2_small.mlxfn")).toBe(true);
+    });
+});

package/dist/__tests__/vibe.test.js

@@ -0,0 +1,15 @@
+import { describe, it, expect } from "vitest";
+import { buildVibeMessage } from "../vibe.js";
+describe("buildVibeMessage", () => {
+    it("serializes the prompt", () => {
+        const parsed = JSON.parse(buildVibeMessage("jazz piano trio"));
+        expect(parsed.prompt).toBe("jazz piano trio");
+    });
+    it("produces valid JSON", () => {
+        expect(() => JSON.parse(buildVibeMessage("test"))).not.toThrow();
+    });
+    it("does not include an intensity field", () => {
+        const parsed = JSON.parse(buildVibeMessage("x"));
+        expect("intensity" in parsed).toBe(false);
+    });
+});

package/dist/cli.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import { install, uninstall, doctor } from "./install.js";
+import { ensureDaemon, runServer, sendLine, socketAlive, stopDaemon, } from "./server.js";
+const USAGE = `claude-music — live AI background music for Claude Code
+
+Usage:
+  claude-music install        Download the daemon + model, register the MCP
+                              server, and install the /music command.
+  claude-music uninstall      Remove the MCP registration and /music command.
+                              (add --purge to also delete the cached binary + model)
+  claude-music doctor         Check that everything is installed correctly.
+  claude-music start          Start the music daemon now.
+  claude-music stop           Stop the music daemon.
+  claude-music status         Report what's currently playing.
+  claude-music mcp            Run the MCP server (used internally by Claude Code).
+
+After 'install', restart Claude Code and type /music.`;
+async function main() {
+    const [cmd, ...rest] = process.argv.slice(2);
+    switch (cmd) {
+        case "mcp":
+            await runServer();
+            return; // server keeps the process alive on the stdio transport
+        case "install":
+            await install();
+            break;
+        case "uninstall":
+            await uninstall(rest.includes("--purge"));
+            break;
+        case "doctor":
+            await doctor();
+            break;
+        case "start": {
+            await ensureDaemon();
+            console.log("Music daemon started.");
+            break;
+        }
+        case "stop":
+            stopDaemon();
+            console.log("Music stopped.");
+            break;
+        case "status": {
+            if (!(await socketAlive())) {
+                console.log("Music is not running.");
+                break;
+            }
+            const reply = await sendLine(JSON.stringify({ status: true }));
+            console.log(reply);
+            break;
+        }
+        case undefined:
+        case "-h":
+        case "--help":
+        case "help":
+            console.log(USAGE);
+            break;
+        default:
+            console.error(`Unknown command: ${cmd}\n`);
+            console.error(USAGE);
+            process.exit(1);
+    }
+}
+main().catch((err) => {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+});

package/dist/download.js

@@ -0,0 +1,154 @@
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { pipeline } from "node:stream/promises";
+import { Readable } from "node:stream";
+import { fileURLToPath } from "node:url";
+import { MAGENTA_HOME } from "./paths.js";
+const HF_REPO = "google/magenta-realtime-2";
+const HF_BASE = `https://huggingface.co/${HF_REPO}/resolve/main`;
+// The complete set of files the mrt2d daemon needs at runtime: the compiled
+// small model + its state, and the shared musiccoca / spectrostream resources.
+// All are public on HuggingFace and download without auth.
+export const MODEL_FILES = [
+    "models/mrt2_small/mrt2_small.mlxfn",
+    "models/mrt2_small/mrt2_small_state.safetensors",
+    "resources/musiccoca/audio_preprocessor.tflite",
+    "resources/musiccoca/mapper.tflite",
+    "resources/musiccoca/music_encoder.tflite",
+    "resources/musiccoca/pretrained_vector_quantizer.tflite",
+    "resources/musiccoca/spm.model",
+    "resources/musiccoca/text_encoder.tflite",
+    "resources/spectrostream/decoder.safetensors",
+    "resources/spectrostream/encoder.safetensors",
+    "resources/spectrostream/quantizer.safetensors",
+    "resources/spectrostream/spectrostream_encoder.mlxfn",
+];
+function humanBytes(n) {
+    if (n >= 1 << 30)
+        return `${(n / (1 << 30)).toFixed(2)} GiB`;
+    if (n >= 1 << 20)
+        return `${(n / (1 << 20)).toFixed(1)} MiB`;
+    if (n >= 1 << 10)
+        return `${(n / (1 << 10)).toFixed(1)} KiB`;
+    return `${n} B`;
+}
+/** Remote Content-Length via a HEAD request (follows redirects). 0 if unknown. */
+async function remoteSize(url) {
+    try {
+        const res = await fetch(url, { method: "HEAD", redirect: "follow" });
+        const len = res.headers.get("content-length");
+        return len ? parseInt(len, 10) : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Stream a URL to a destination file, printing line-buffered progress (survives
+ * pipes/tee — see the project's progress-visibility convention). Downloads to a
+ * .part file and renames on success so an interrupted download never looks done.
+ */
+async function downloadFile(url, dest, label) {
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    const res = await fetch(url, { redirect: "follow" });
+    if (!res.ok || !res.body) {
+        throw new Error(`download failed (${res.status}) for ${url}`);
+    }
+    const total = parseInt(res.headers.get("content-length") || "0", 10);
+    const tmp = dest + ".part";
+    let received = 0;
+    let lastTick = 0;
+    const out = fs.createWriteStream(tmp);
+    const src = Readable.fromWeb(res.body);
+    src.on("data", (chunk) => {
+        received += chunk.length;
+        const now = Date.now();
+        // Throttle progress lines to ~1/sec so logs stay readable.
+        if (now - lastTick >= 1000) {
+            lastTick = now;
+            const pct = total ? ` (${((received / total) * 100).toFixed(0)}%)` : "";
+            console.log(`    ${label}: ${humanBytes(received)}${total ? ` / ${humanBytes(total)}` : ""}${pct}`);
+        }
+    });
+    await pipeline(src, out);
+    fs.renameSync(tmp, dest);
+    console.log(`    ${label}: done (${humanBytes(received)})`);
+}
+/**
+ * Download all model + resource files into MAGENTA_HOME, skipping any file that
+ * already exists locally with the same size as the remote. Returns how many
+ * files were actually fetched.
+ */
+export async function downloadModel() {
+    let fetched = 0;
+    console.log(`==> Downloading model + resources to ${MAGENTA_HOME}`);
+    for (let i = 0; i < MODEL_FILES.length; i++) {
+        const rel = MODEL_FILES[i];
+        const dest = path.join(MAGENTA_HOME, rel);
+        const url = `${HF_BASE}/${rel}`;
+        const tag = `[${i + 1}/${MODEL_FILES.length}] ${rel}`;
+        if (fs.existsSync(dest)) {
+            const local = fs.statSync(dest).size;
+            const remote = await remoteSize(url);
+            if (remote > 0 && local === remote) {
+                console.log(`  skip ${tag} (already present, ${humanBytes(local)})`);
+                continue;
+            }
+        }
+        console.log(`  get  ${tag}`);
+        await downloadFile(url, dest, rel.split("/").pop() || rel);
+        fetched++;
+    }
+    console.log(`==> Model ready (${fetched} file(s) downloaded).`);
+    return fetched;
+}
+/**
+ * Download the prebuilt daemon tarball and extract it into binDir. The tarball
+ * contains the mrt2d binary plus any bundled dylibs. Returns the path to the
+ * extracted binary.
+ */
+export async function downloadBinary(url, binDir) {
+    fs.mkdirSync(binDir, { recursive: true });
+    let tmpTar;
+    let fromLocal = false;
+    if (url.startsWith("file://") || url.startsWith("/")) {
+        // Local tarball (used for testing a freshly built artifact). Node's fetch
+        // doesn't handle file:// URLs, so resolve to a path and use it directly.
+        tmpTar = url.startsWith("file://") ? fileURLToPath(url) : url;
+        fromLocal = true;
+        if (!fs.existsSync(tmpTar)) {
+            throw new Error(`local tarball not found: ${tmpTar}`);
+        }
+        console.log(`==> Using local daemon tarball ${tmpTar}`);
+    }
+    else {
+        tmpTar = path.join(os.tmpdir(), `mrt2d-${process.pid}-${Date.now()}.tar.gz`);
+        console.log(`==> Downloading prebuilt daemon from ${url}`);
+        await downloadFile(url, tmpTar, "mrt2d.tar.gz");
+    }
+    console.log(`==> Extracting to ${binDir}`);
+    await new Promise((resolve, reject) => {
+        const tar = spawn("tar", ["-xzf", tmpTar, "-C", binDir], {
+            stdio: "inherit",
+        });
+        tar.on("error", reject);
+        tar.on("exit", (code) => code === 0 ? resolve() : reject(new Error(`tar exited ${code}`)));
+    });
+    if (!fromLocal)
+        fs.rmSync(tmpTar, { force: true });
+    const bin = path.join(binDir, "mrt2d");
+    if (!fs.existsSync(bin)) {
+        throw new Error(`tarball did not contain an mrt2d binary in ${binDir}`);
+    }
+    fs.chmodSync(bin, 0o755);
+    // Clear the quarantine attribute so Gatekeeper doesn't block a downloaded
+    // binary. Best-effort: harmless if the attribute isn't set.
+    await new Promise((resolve) => {
+        const xattr = spawn("xattr", ["-dr", "com.apple.quarantine", binDir]);
+        xattr.on("error", () => resolve());
+        xattr.on("exit", () => resolve());
+    });
+    return bin;
+}

package/dist/install.js

@@ -0,0 +1,232 @@
+import { spawn, spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { downloadBinary, downloadModel } from "./download.js";
+import { BIN_DIR, CLAUDE_MUSIC_HOME, COMMANDS_DIR, DAEMON_BIN, MAGENTA_HOME, MODEL_FILE, MUSIC_COMMAND, RESOURCES_DIR, } from "./paths.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = path.resolve(__dirname, "..");
+const CLI_JS = path.join(__dirname, "cli.js");
+const TEMPLATE_MUSIC = path.join(PKG_ROOT, "templates", "music.md");
+const DAEMON_SRC = path.join(PKG_ROOT, "daemon");
+const DEFAULT_BINARY_URL = "https://github.com/noo-bass/claude-music/releases/latest/download/mrt2d-darwin-arm64.tar.gz";
+// ---------------------------------------------------------------------------
+// small helpers
+// ---------------------------------------------------------------------------
+/** Run a command, inheriting stdio. Resolves with the exit code. */
+function run(cmd, args) {
+    return new Promise((resolve) => {
+        const c = spawn(cmd, args, { stdio: "inherit" });
+        c.on("error", () => resolve(127));
+        c.on("exit", (code) => resolve(code ?? 1));
+    });
+}
+function have(cmd) {
+    // `command -v` is a shell builtin; run it as a single shell string (no args
+    // array) so we don't trip Node's DEP0190 shell-args warning. cmd is always a
+    // fixed literal ("claude" / "git" / "cmake"), so interpolation is safe.
+    const r = spawnSync(`command -v ${cmd}`, { shell: true, stdio: "ignore" });
+    return r.status === 0;
+}
+// ---------------------------------------------------------------------------
+// install steps
+// ---------------------------------------------------------------------------
+function preflight() {
+    console.log("==> Checking prerequisites...");
+    if (process.platform !== "darwin") {
+        throw new Error("macOS required (Magenta RealTime uses MLX/Metal).");
+    }
+    if (process.arch !== "arm64") {
+        throw new Error("Apple Silicon (arm64) required.");
+    }
+    const major = parseInt(process.versions.node.split(".")[0], 10);
+    if (major < 18) {
+        throw new Error(`Node >= 18 required (have ${process.versions.node}).`);
+    }
+    if (!have("claude")) {
+        throw new Error("The `claude` CLI is not on your PATH — install Claude Code first.");
+    }
+    console.log("    macOS arm64, Node " + process.versions.node + ", claude CLI ✓");
+}
+/** True if the binary exists and runs (exec bit + loads without crashing). */
+function binaryUsable() {
+    if (!fs.existsSync(DAEMON_BIN))
+        return false;
+    // We can't fully launch it without the model, but a missing-dylib failure
+    // surfaces immediately as a non-spawnable file. A bare exec with no model
+    // exits non-zero quickly; we only treat ENOENT/dyld failures as "unusable".
+    const r = spawnSync(DAEMON_BIN, ["--model", "/nonexistent"], {
+        timeout: 5000,
+    });
+    if (r.error && r.error.code === "ENOENT") {
+        return false;
+    }
+    // A dyld load failure prints to stderr and yields a signal/137-ish status.
+    const stderr = (r.stderr?.toString() || "") + (r.stdout?.toString() || "");
+    if (/dyld|Library not loaded|image not found/i.test(stderr))
+        return false;
+    return true;
+}
+async function ensureBinary() {
+    if (binaryUsable()) {
+        console.log(`==> Daemon already installed: ${DAEMON_BIN}`);
+        return;
+    }
+    const url = process.env.CLAUDE_MUSIC_BINARY_URL || DEFAULT_BINARY_URL;
+    try {
+        await downloadBinary(url, BIN_DIR);
+        if (!binaryUsable()) {
+            throw new Error("downloaded binary is not runnable on this machine");
+        }
+        console.log(`==> Daemon installed: ${DAEMON_BIN}`);
+    }
+    catch (err) {
+        console.log(`==> Prebuilt download failed (${err.message}).`);
+        console.log("==> Falling back to build-from-source...");
+        await buildFromSource();
+    }
+}
+/**
+ * Fallback path: clone magenta-realtime, wire in the bundled daemon source, and
+ * build mrt2d with CMake. Used only when no prebuilt binary can be fetched/run.
+ * Requires git + cmake + Xcode command-line tools.
+ */
+async function buildFromSource() {
+    for (const tool of ["git", "cmake"]) {
+        if (!have(tool)) {
+            throw new Error(`build-from-source needs '${tool}', which is not installed. ` +
+                "Install Xcode CLT + CMake, or set CLAUDE_MUSIC_BINARY_URL to a working prebuilt.");
+        }
+    }
+    const srcRoot = path.join(CLAUDE_MUSIC_HOME, "src");
+    const mrt = path.join(srcRoot, "magenta-realtime");
+    fs.mkdirSync(srcRoot, { recursive: true });
+    if (!fs.existsSync(path.join(mrt, "CMakeLists.txt"))) {
+        console.log("==> Cloning magenta-realtime (shallow)...");
+        const code = await run("git", [
+            "clone",
+            "--depth",
+            "1",
+            "https://github.com/magenta/magenta-realtime.git",
+            mrt,
+        ]);
+        if (code !== 0)
+            throw new Error("git clone failed");
+    }
+    // Wire the bundled daemon source into the magenta-realtime build (idempotent).
+    const cmakeLists = path.join(mrt, "CMakeLists.txt");
+    const marker = "claude-music mrt2d daemon (added by claude-music install)";
+    let contents = fs.readFileSync(cmakeLists, "utf8");
+    if (!contents.includes(marker)) {
+        contents +=
+            `\n# ${marker}\n` +
+                `add_subdirectory(${JSON.stringify(DAEMON_SRC)} ` +
+                `${JSON.stringify(path.join(mrt, "build", "mrt2d"))})\n`;
+        fs.writeFileSync(cmakeLists, contents);
+    }
+    console.log("==> Building mrt2d (first build pulls C++ deps — several minutes)...");
+    const cpus = String(os.cpus().length);
+    let code = await run("cmake", [
+        "-S",
+        mrt,
+        "-B",
+        path.join(mrt, "build"),
+        "-DCMAKE_BUILD_TYPE=Release",
+        "-DCMAKE_POLICY_VERSION_MINIMUM=3.5",
+        "-DCMAKE_POLICY_DEFAULT_CMP0169=OLD",
+        "-Wno-dev",
+    ]);
+    if (code !== 0)
+        throw new Error("cmake configure failed");
+    code = await run("cmake", [
+        "--build",
+        path.join(mrt, "build"),
+        "--target",
+        "mrt2d",
+        "-j",
+        cpus,
+    ]);
+    if (code !== 0)
+        throw new Error("cmake build failed");
+    const built = path.join(mrt, "build", "mrt2d", "mrt2d");
+    if (!fs.existsSync(built))
+        throw new Error("build produced no mrt2d binary");
+    fs.mkdirSync(BIN_DIR, { recursive: true });
+    fs.copyFileSync(built, DAEMON_BIN);
+    fs.chmodSync(DAEMON_BIN, 0o755);
+    console.log(`==> Daemon built: ${DAEMON_BIN}`);
+}
+async function registerMcp() {
+    console.log("==> Registering mrt2-mcp with Claude Code...");
+    // Idempotent: drop any prior registration, then add. Use node + absolute CLI
+    // path so it works regardless of whether the global bin is on PATH.
+    await run("claude", ["mcp", "remove", "mrt2-mcp", "-s", "user"]);
+    const code = await run("claude", [
+        "mcp",
+        "add",
+        "mrt2-mcp",
+        "-s",
+        "user",
+        "--",
+        process.execPath,
+        CLI_JS,
+        "mcp",
+    ]);
+    if (code !== 0)
+        throw new Error("`claude mcp add` failed");
+}
+function installCommand() {
+    console.log("==> Installing /music command...");
+    fs.mkdirSync(COMMANDS_DIR, { recursive: true });
+    fs.copyFileSync(TEMPLATE_MUSIC, MUSIC_COMMAND);
+}
+// ---------------------------------------------------------------------------
+// entry points
+// ---------------------------------------------------------------------------
+export async function install() {
+    preflight();
+    await ensureBinary();
+    await downloadModel();
+    await registerMcp();
+    installCommand();
+    console.log("");
+    console.log("claude-music installed.");
+    console.log("  Restart Claude Code, then type /music to start. It steers itself as you");
+    console.log("  work and stops when you end the session.");
+}
+export async function uninstall(purge) {
+    console.log("==> Removing mrt2-mcp registration...");
+    await run("claude", ["mcp", "remove", "mrt2-mcp", "-s", "user"]);
+    console.log("==> Removing /music command...");
+    fs.rmSync(MUSIC_COMMAND, { force: true });
+    if (purge) {
+        console.log(`==> Purging ${CLAUDE_MUSIC_HOME} and ${MAGENTA_HOME}...`);
+        fs.rmSync(CLAUDE_MUSIC_HOME, { recursive: true, force: true });
+        fs.rmSync(MAGENTA_HOME, { recursive: true, force: true });
+    }
+    console.log("claude-music uninstalled.");
+}
+export async function doctor() {
+    const ok = (b) => (b ? "OK  " : "MISS");
+    const platformOk = process.platform === "darwin" && process.arch === "arm64";
+    const claudeOk = have("claude");
+    const binOk = fs.existsSync(DAEMON_BIN);
+    const modelOk = fs.existsSync(MODEL_FILE);
+    const resourcesOk = fs.existsSync(RESOURCES_DIR);
+    let mcpOk = false;
+    const r = spawnSync("claude", ["mcp", "list"], { encoding: "utf8" });
+    if (r.status === 0)
+        mcpOk = /mrt2-mcp/.test(r.stdout || "");
+    const cmdOk = fs.existsSync(MUSIC_COMMAND);
+    console.log("claude-music doctor");
+    console.log(`  [${ok(platformOk)}] platform: ${process.platform}/${process.arch}`);
+    console.log(`  [${ok(claudeOk)}] claude CLI on PATH`);
+    console.log(`  [${ok(binOk)}] daemon binary: ${DAEMON_BIN}`);
+    console.log(`  [${ok(modelOk)}] model: ${MODEL_FILE}`);
+    console.log(`  [${ok(resourcesOk)}] resources: ${RESOURCES_DIR}`);
+    console.log(`  [${ok(mcpOk)}] mrt2-mcp registered`);
+    console.log(`  [${ok(cmdOk)}] /music command: ${MUSIC_COMMAND}`);
+    const allOk = platformOk && claudeOk && binOk && modelOk && resourcesOk && mcpOk && cmdOk;
+    console.log(allOk ? "All good — restart Claude Code and /music." : "Run: claude-music install");
+}

package/dist/paths.js

@@ -0,0 +1,26 @@
+import * as os from "node:os";
+import * as path from "node:path";
+// Central path constants for claude-music. Everything the installer writes and
+// everything the MCP server reads is resolved here so the layout is defined in
+// exactly one place.
+const HOME = os.homedir();
+/** Per-user claude-music state (downloaded daemon binary lives here). */
+export const CLAUDE_MUSIC_HOME = path.join(HOME, ".claude-music");
+/** Directory holding the prebuilt mrt2d binary (+ any bundled dylibs). */
+export const BIN_DIR = path.join(CLAUDE_MUSIC_HOME, "bin");
+/**
+ * The mrt2d daemon binary. Override with MRT2D_BIN (used by the build-from-source
+ * fallback, which leaves the binary inside the magenta-realtime build tree).
+ */
+export const DAEMON_BIN = process.env.MRT2D_BIN || path.join(BIN_DIR, "mrt2d");
+/** Where the model + shared resources are downloaded. The daemon hardcodes this. */
+export const MAGENTA_HOME = path.join(HOME, "Documents", "Magenta", "magenta-rt-v2");
+export const MODEL_FILE = path.join(MAGENTA_HOME, "models", "mrt2_small", "mrt2_small.mlxfn");
+export const RESOURCES_DIR = path.join(MAGENTA_HOME, "resources");
+/** Runtime artefacts created by the daemon. */
+export const SOCKET_PATH = path.join(HOME, ".mrt2d.sock");
+export const PID_PATH = path.join(HOME, ".mrt2d.pid");
+export const LOG_PATH = path.join(HOME, ".mrt2d.log");
+/** Claude Code user-scope slash commands directory. */
+export const COMMANDS_DIR = path.join(HOME, ".claude", "commands");
+export const MUSIC_COMMAND = path.join(COMMANDS_DIR, "music.md");

package/dist/server.js

@@ -0,0 +1,128 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as net from "node:net";
+import { z } from "zod";
+import { buildVibeMessage } from "./vibe.js";
+import { DAEMON_BIN, LOG_PATH, PID_PATH, SOCKET_PATH } from "./paths.js";
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Can we actually connect to the daemon's socket right now? */
+export function socketAlive() {
+    return new Promise((resolve) => {
+        const c = net.createConnection(SOCKET_PATH);
+        c.on("connect", () => {
+            c.destroy();
+            resolve(true);
+        });
+        c.on("error", () => resolve(false));
+    });
+}
+/**
+ * Ensure the daemon is running. If not, spawn it detached and wait for its
+ * socket. This is what makes `/music` a single silent action — the caller never
+ * has to launch the daemon separately.
+ */
+export async function ensureDaemon() {
+    if (await socketAlive())
+        return;
+    if (!fs.existsSync(DAEMON_BIN)) {
+        throw new Error(`mrt2d not installed at ${DAEMON_BIN} — run: claude-music install`);
+    }
+    const out = fs.openSync(LOG_PATH, "a");
+    const child = spawn(DAEMON_BIN, [], {
+        detached: true,
+        stdio: ["ignore", out, out],
+    });
+    child.unref();
+    // Model load is fast for mrt2_small (~2s) but allow generous headroom.
+    for (let i = 0; i < 60; i++) {
+        await sleep(1000);
+        if (await socketAlive())
+            return;
+    }
+    throw new Error(`daemon did not come up within 60s — check ${LOG_PATH}`);
+}
+/** Send one newline-terminated JSON command to the daemon and await its reply. */
+export function sendLine(message) {
+    return new Promise((resolve, reject) => {
+        const client = net.createConnection(SOCKET_PATH);
+        let buf = "";
+        client.on("connect", () => client.write(message + "\n"));
+        client.on("data", (data) => {
+            buf += data.toString();
+            if (buf.includes("\n")) {
+                client.destroy();
+                resolve(buf.trim());
+            }
+        });
+        client.on("error", (err) => reject(new Error(`socket error: ${err.message}`)));
+        client.setTimeout(3000, () => {
+            client.destroy();
+            reject(new Error("timeout — daemon did not respond within 3s"));
+        });
+    });
+}
+/** Stop the daemon (SIGTERM the recorded pid) and clean up its socket. */
+export function stopDaemon() {
+    if (fs.existsSync(PID_PATH)) {
+        const pid = parseInt(fs.readFileSync(PID_PATH, "utf8").trim(), 10);
+        if (pid) {
+            try {
+                process.kill(pid, "SIGTERM");
+            }
+            catch {
+                /* already gone */
+            }
+        }
+        fs.rmSync(PID_PATH, { force: true });
+    }
+    fs.rmSync(SOCKET_PATH, { force: true });
+}
+/** 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" });
+    server.tool("set_music_vibe", "You are the DJ scoring this coding session in real time. If music isn't " +
+        "playing, this starts it. There is NO fixed playlist — pick whatever genre, " +
+        "mood, tempo, and instrumentation genuinely fit THIS project and THIS moment, " +
+        "with taste and opinion. React to the real work: the project's character " +
+        "(a playful game vs gnarly infra vs a slick frontend all sound different), " +
+        "what you're doing (careful exploration, a flow-state grind, hunting a nasty " +
+        "bug, mechanical cleanup, a victory lap after green tests), and how it feels " +
+        "(stuck and tense, cruising, triumphant). Let the soundtrack carry that arc " +
+        "and evolve as the work shifts — vary it, don't loop one vibe. Call this " +
+        "silently at natural transitions; never announce it.", {
+        prompt: z.string().describe("Free-text music style — be specific and inventive: genre, instruments, " +
+            "era, tempo, mood, AND energy (put the intensity right in the words). " +
+            "Anything MusicCoCa can interpret. e.g. " +
+            '"1980s synthwave, neon and propulsive", "sparse, slow modular ambient for ' +
+            'deep reading", "frantic high-BPM drum-and-bass while the bug fights back", ' +
+            '"warm gospel organ, triumphant, the tests are finally green".'),
+    }, async ({ prompt }) => {
+        try {
+            await ensureDaemon();
+            await sendLine(buildVibeMessage(prompt));
+            return { content: [{ type: "text", text: "ok" }] };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: err.message }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("stop_music", "Stop the background music daemon. Use when the user asks to stop the music.", {}, async () => {
+        try {
+            stopDaemon();
+            return { content: [{ type: "text", text: "stopped" }] };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: err.message }],
+                isError: true,
+            };
+        }
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/dist/vibe.js

@@ -0,0 +1,3 @@
+export function buildVibeMessage(prompt) {
+    return JSON.stringify({ prompt });
+}