deadman-fm 0.1.1

package/dist/commands/create.d.ts

@@ -0,0 +1,17 @@
+/**
+ * deadman create — Create a station and upload audio files
+ *
+ * 1. Scans the music folder for audio files (mp3, wav, flac, ogg, m4a)
+ * 2. Creates a Hypercore feed
+ * 3. Transcodes each file → MPEG-TS segments → encrypts → appends to feed
+ * 4. Joins Hyperswarm to start seeding
+ * 5. If --watch: monitors folder for new files
+ */
+interface CreateOptions {
+    name: string;
+    genre: string;
+    music: string;
+    watch?: boolean;
+}
+export declare function createStation(opts: CreateOptions): Promise<void>;
+export {};

package/dist/commands/create.js

@@ -0,0 +1,221 @@
+/**
+ * deadman create — Create a station and upload audio files
+ *
+ * 1. Scans the music folder for audio files (mp3, wav, flac, ogg, m4a)
+ * 2. Creates a Hypercore feed
+ * 3. Transcodes each file → MPEG-TS segments → encrypts → appends to feed
+ * 4. Joins Hyperswarm to start seeding
+ * 5. If --watch: monitors folder for new files
+ */
+import { readdirSync, statSync } from "node:fs";
+import { join, extname } from "node:path";
+import { spawn } from "node:child_process";
+import { createCipheriv, randomBytes } from "node:crypto";
+import { homedir } from "node:os";
+import { mkdirSync, writeFileSync } from "node:fs";
+import Hypercore from "hypercore";
+import Hyperswarm from "hyperswarm";
+const AUDIO_EXTS = new Set([
+    ".mp3",
+    ".wav",
+    ".flac",
+    ".ogg",
+    ".m4a",
+    ".aac",
+    ".opus",
+]);
+const SEGMENT_BYTES = 96_000;
+const ALGO = "chacha20-poly1305";
+const KEY_BYTES = 32;
+const NONCE_BYTES = 12;
+const TAG_BYTES = 16;
+export async function createStation(opts) {
+    const musicPath = opts.music.replace("~", homedir());
+    console.log(`💀 Creating station: ${opts.name}`);
+    console.log(`   Genre: ${opts.genre}`);
+    console.log(`   Music: ${musicPath}`);
+    // Find audio files
+    const files = scanForAudio(musicPath);
+    if (files.length === 0) {
+        console.error("❌ No audio files found in", musicPath);
+        process.exit(1);
+    }
+    console.log(`   Found ${files.length} audio file(s)`);
+    // Create storage
+    const stationDir = join(homedir(), ".deadman-fm", "stations", slugify(opts.name));
+    mkdirSync(stationDir, { recursive: true });
+    // Generate station key
+    const stationKey = randomBytes(KEY_BYTES);
+    writeFileSync(join(stationDir, "station.key"), stationKey.toString("hex"));
+    console.log(`   Key: ${stationKey.toString("hex").slice(0, 16)}...`);
+    // Create Hypercore feed
+    const feedPath = join(stationDir, "feed");
+    const core = new Hypercore(feedPath);
+    await core.ready();
+    console.log(`   Feed: ${core.key.toString("hex").slice(0, 16)}...`);
+    // Transcode and ingest each file
+    let totalSegments = 0;
+    for (const file of files) {
+        const pretty = prettifyPath(file);
+        const label = [pretty.artist, pretty.album, pretty.title]
+            .filter(Boolean)
+            .join(" — ");
+        console.log(`   📀 ${label}`);
+        const segments = await transcodeFile(join(musicPath, file), core, stationKey, totalSegments);
+        totalSegments += segments;
+        console.log(`      → ${segments} segments`);
+    }
+    console.log(`\n   Total: ${totalSegments} segments (~${Math.round(totalSegments * 6)}s of audio)`);
+    // Save station metadata
+    const meta = {
+        name: opts.name,
+        genre: opts.genre,
+        feedKey: core.key.toString("hex"),
+        totalSegments,
+        createdAt: new Date().toISOString(),
+    };
+    writeFileSync(join(stationDir, "station.json"), JSON.stringify(meta, null, 2));
+    // Join swarm
+    const swarm = new Hyperswarm();
+    swarm.on("connection", (socket) => {
+        console.log("   🔗 Peer connected");
+        core.replicate(socket);
+    });
+    const topic = core.discoveryKey;
+    swarm.join(topic, { server: true, client: true });
+    await swarm.flush();
+    console.log(`\n💀 Station "${opts.name}" is live and seeding`);
+    console.log(`   Feed key: ${core.key.toString("hex")}`);
+    console.log(`   ${totalSegments} segments on the network`);
+    console.log(`\n   Press Ctrl+C to stop seeding`);
+    // Watch mode
+    if (opts.watch) {
+        console.log(`   👁  Watching ${musicPath} for new files...`);
+        const { watch } = await import("chokidar");
+        const watcher = watch(musicPath, {
+            ignoreInitial: true,
+            awaitWriteFinish: { stabilityThreshold: 2000 },
+        });
+        watcher.on("add", async (filePath) => {
+            const ext = extname(filePath).toLowerCase();
+            if (!AUDIO_EXTS.has(ext))
+                return;
+            console.log(`   📀 New file: ${filePath}`);
+            const segments = await transcodeFile(filePath, core, stationKey, totalSegments);
+            totalSegments += segments;
+            meta.totalSegments = totalSegments;
+            writeFileSync(join(stationDir, "station.json"), JSON.stringify(meta, null, 2));
+            console.log(`      → ${segments} segments (total: ${totalSegments})`);
+        });
+    }
+    // Keep alive
+    await new Promise(() => { });
+}
+function scanForAudio(dir) {
+    const results = [];
+    function walk(d, prefix) {
+        try {
+            for (const entry of readdirSync(d)) {
+                const full = join(d, entry);
+                try {
+                    const s = statSync(full);
+                    if (s.isDirectory()) {
+                        walk(full, prefix ? `${prefix}/${entry}` : entry);
+                    }
+                    else if (s.isFile() &&
+                        AUDIO_EXTS.has(extname(entry).toLowerCase())) {
+                        results.push(prefix ? `${prefix}/${entry}` : entry);
+                    }
+                }
+                catch { }
+            }
+        }
+        catch { }
+    }
+    walk(dir, "");
+    return results.sort();
+}
+function prettifyName(raw) {
+    return raw
+        .replace(/\.[^.]+$/, "") // remove extension
+        .replace(/[_-]+/g, " ") // underscores/hyphens → spaces
+        .replace(/([a-z])([A-Z])/g, "$1 $2") // camelCase → spaces
+        .replace(/#\d+$/, "") // remove trailing #01 etc
+        .replace(/\s+/g, " ") // collapse whitespace
+        .trim()
+        .replace(/\b\w/g, (c) => c.toUpperCase()); // title case
+}
+function prettifyPath(filePath) {
+    const parts = filePath.split("/");
+    // Root folder is ignored (that's just ~/Music or whatever they picked)
+    // Structure: Artist/Album/Song.mp3
+    if (parts.length >= 3) {
+        return {
+            artist: prettifyName(parts[parts.length - 3]),
+            album: prettifyName(parts[parts.length - 2]),
+            title: prettifyName(parts[parts.length - 1]),
+        };
+    }
+    if (parts.length === 2) {
+        return {
+            artist: prettifyName(parts[0]),
+            album: "",
+            title: prettifyName(parts[1]),
+        };
+    }
+    return { artist: "", album: "", title: prettifyName(parts[0]) };
+}
+function slugify(s) {
+    return s
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/(^-|-$)/g, "");
+}
+function encryptSegment(key, plaintext, segIndex) {
+    const nonce = Buffer.alloc(NONCE_BYTES);
+    nonce.writeUInt32BE(segIndex, NONCE_BYTES - 4);
+    const cipher = createCipheriv(ALGO, key, nonce, {
+        authTagLength: TAG_BYTES,
+    });
+    const encrypted = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return Buffer.concat([nonce, encrypted, tag]);
+}
+function transcodeFile(filePath, core, stationKey, startIndex) {
+    return new Promise((resolve, reject) => {
+        const ffmpeg = spawn("ffmpeg", ["-i", filePath, "-c:a", "aac", "-b:a", "128k", "-f", "mpegts", "pipe:1"], { stdio: ["pipe", "pipe", "pipe"] });
+        let segmentBuffer = [];
+        let accumulated = 0;
+        let segmentCount = 0;
+        const appendQueue = [];
+        ffmpeg.stdout.on("data", (chunk) => {
+            segmentBuffer.push(chunk);
+            accumulated += chunk.length;
+            if (accumulated >= SEGMENT_BYTES) {
+                const plaintext = Buffer.concat(segmentBuffer);
+                segmentBuffer = [];
+                accumulated = 0;
+                const idx = startIndex + segmentCount++;
+                const encrypted = encryptSegment(stationKey, plaintext, idx);
+                appendQueue.push(core.append(encrypted).then(() => { }));
+            }
+        });
+        ffmpeg.stdout.on("end", async () => {
+            // Flush remaining
+            if (segmentBuffer.length > 0) {
+                const plaintext = Buffer.concat(segmentBuffer);
+                const idx = startIndex + segmentCount++;
+                const encrypted = encryptSegment(stationKey, plaintext, idx);
+                appendQueue.push(core.append(encrypted).then(() => { }));
+            }
+            await Promise.all(appendQueue);
+            resolve(segmentCount);
+        });
+        ffmpeg.stderr.on("data", () => { }); // suppress ffmpeg output
+        ffmpeg.on("error", reject);
+        ffmpeg.on("close", (code) => {
+            if (code !== 0 && code !== null)
+                reject(new Error(`ffmpeg exit ${code}`));
+        });
+    });
+}

package/dist/commands/interactive.d.ts

@@ -0,0 +1,16 @@
+/**
+ * deadman — Interactive menu mode
+ *
+ * The hero experience. Run `deadman` with no args.
+ * Walks through everything: create, sync, connect, list, status.
+ *
+ * Design principles:
+ *   - No flags to memorize
+ *   - Arrow-key navigation via @clack/prompts
+ *   - Every step confirms before acting
+ *   - Progress visible at all times
+ *   - Errors explain what to do next
+ */
+export declare function loadApiKey(): Promise<string | null>;
+export declare function saveApiKey(key: string): Promise<void>;
+export declare function interactive(): Promise<void>;

package/dist/commands/interactive.js

@@ -0,0 +1,636 @@
+/**
+ * deadman — Interactive menu mode
+ *
+ * The hero experience. Run `deadman` with no args.
+ * Walks through everything: create, sync, connect, list, status.
+ *
+ * Design principles:
+ *   - No flags to memorize
+ *   - Arrow-key navigation via @clack/prompts
+ *   - Every step confirms before acting
+ *   - Progress visible at all times
+ *   - Errors explain what to do next
+ */
+import * as p from "@clack/prompts";
+import { isCancel } from "@clack/prompts";
+import { readdirSync, statSync, existsSync, readFileSync } from "node:fs";
+import { join, extname, basename } from "node:path";
+import { homedir } from "node:os";
+import { execSync } from "node:child_process";
+// ---------------------------------------------------------------------------
+// Audio file scanner (mirrors logic in create.ts without the transcode step)
+// ---------------------------------------------------------------------------
+const AUDIO_EXTS = new Set([
+    ".mp3",
+    ".wav",
+    ".flac",
+    ".ogg",
+    ".m4a",
+    ".aac",
+    ".opus",
+]);
+function scanMusicFolder(dir) {
+    const results = [];
+    function walk(d, relPrefix) {
+        try {
+            for (const entry of readdirSync(d)) {
+                const full = join(d, entry);
+                try {
+                    const s = statSync(full);
+                    const rel = relPrefix ? `${relPrefix}/${entry}` : entry;
+                    if (s.isDirectory()) {
+                        walk(full, rel);
+                    }
+                    else if (s.isFile() &&
+                        AUDIO_EXTS.has(extname(entry).toLowerCase())) {
+                        results.push({ relativePath: rel, ...parsePath(rel) });
+                    }
+                }
+                catch {
+                    // skip unreadable entries
+                }
+            }
+        }
+        catch {
+            // skip unreadable dirs
+        }
+    }
+    walk(dir, "");
+    return results.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+function prettifyName(raw) {
+    return raw
+        .replace(/\.[^.]+$/, "")
+        .replace(/[_-]+/g, " ")
+        .replace(/([a-z])([A-Z])/g, "$1 $2")
+        .replace(/#\d+$/, "")
+        .replace(/\s+/g, " ")
+        .trim()
+        .replace(/\b\w/g, (ch) => ch.toUpperCase());
+}
+function parsePath(filePath) {
+    const parts = filePath.split("/");
+    if (parts.length >= 3) {
+        return {
+            artist: prettifyName(parts[parts.length - 3]),
+            album: prettifyName(parts[parts.length - 2]),
+            title: prettifyName(parts[parts.length - 1]),
+        };
+    }
+    if (parts.length === 2) {
+        return {
+            artist: prettifyName(parts[0]),
+            album: "",
+            title: prettifyName(parts[1]),
+        };
+    }
+    return { artist: "", album: "", title: prettifyName(parts[0]) };
+}
+function loadLocalStations() {
+    const stationsDir = join(homedir(), ".deadman-fm", "stations");
+    if (!existsSync(stationsDir))
+        return [];
+    const results = [];
+    try {
+        for (const slug of readdirSync(stationsDir)) {
+            const metaPath = join(stationsDir, slug, "station.json");
+            if (existsSync(metaPath)) {
+                try {
+                    const meta = JSON.parse(readFileSync(metaPath, "utf8"));
+                    results.push({ slug, meta });
+                }
+                catch {
+                    // skip corrupt
+                }
+            }
+        }
+    }
+    catch {
+        // no stations dir
+    }
+    return results;
+}
+// ---------------------------------------------------------------------------
+// Keychain helpers
+// ---------------------------------------------------------------------------
+export async function loadApiKey() {
+    const { platform } = await import("node:os");
+    const plat = platform();
+    if (plat === "darwin") {
+        try {
+            const key = execSync('security find-generic-password -a "deadman-fm" -s "openhome-api-key" -w 2>/dev/null', { encoding: "utf8" }).trim();
+            if (key)
+                return key;
+        }
+        catch {
+            // not found
+        }
+    }
+    if (plat === "linux") {
+        try {
+            const key = execSync("secret-tool lookup service deadman-fm key openhome-api-key 2>/dev/null", { encoding: "utf8" }).trim();
+            if (key)
+                return key;
+        }
+        catch {
+            // not found
+        }
+    }
+    const configPath = join(homedir(), ".deadman-fm", "config.json");
+    if (existsSync(configPath)) {
+        try {
+            const config = JSON.parse(readFileSync(configPath, "utf8"));
+            if (config.apiKey)
+                return config.apiKey;
+        }
+        catch {
+            // corrupt config
+        }
+    }
+    return null;
+}
+export async function saveApiKey(key) {
+    const { platform } = await import("node:os");
+    const { mkdirSync, writeFileSync, chmodSync } = await import("node:fs");
+    const plat = platform();
+    if (plat === "darwin") {
+        try {
+            try {
+                execSync('security delete-generic-password -a "deadman-fm" -s "openhome-api-key" 2>/dev/null');
+            }
+            catch {
+                // already absent
+            }
+            execSync(`security add-generic-password -a "deadman-fm" -s "openhome-api-key" -w "${key}" -U`);
+            return;
+        }
+        catch {
+            // fall through to file
+        }
+    }
+    if (plat === "linux") {
+        try {
+            execSync(`echo -n "${key}" | secret-tool store --label "deadman.fm" service deadman-fm key openhome-api-key 2>/dev/null`);
+            return;
+        }
+        catch {
+            // fall through to file
+        }
+    }
+    const configDir = join(homedir(), ".deadman-fm");
+    const configPath = join(configDir, "config.json");
+    try {
+        mkdirSync(configDir, { recursive: true });
+        writeFileSync(configPath, JSON.stringify({ apiKey: key }, null, 2));
+        try {
+            chmodSync(configPath, 0o600);
+        }
+        catch {
+            // permissions not critical
+        }
+        p.log.info("Saved to ~/.deadman-fm/config.json");
+    }
+    catch {
+        p.log.warn("Could not save key. You will need to enter it next time.");
+    }
+}
+// ---------------------------------------------------------------------------
+// Status checks
+// ---------------------------------------------------------------------------
+function checkRelay() {
+    try {
+        execSync("curl -sf http://localhost:4040/health --max-time 1 > /dev/null 2>&1");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function checkLocalLink() {
+    try {
+        const out = execSync("pgrep -f 'deadman' 2>/dev/null || true", {
+            encoding: "utf8",
+        }).trim();
+        return out.split("\n").filter(Boolean).length > 1;
+    }
+    catch {
+        return false;
+    }
+}
+function loadSavedWallet() {
+    const configPath = join(homedir(), ".deadman-fm", "config.json");
+    if (existsSync(configPath)) {
+        try {
+            const config = JSON.parse(readFileSync(configPath, "utf8"));
+            return config.walletAddress ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Cancel guard — exits gracefully on Ctrl+C
+// ---------------------------------------------------------------------------
+function guardCancel(value) {
+    if (isCancel(value)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+    }
+}
+// ---------------------------------------------------------------------------
+// Main interactive entry point
+// ---------------------------------------------------------------------------
+export async function interactive() {
+    p.intro("💀 deadman.fm — Radio that plays forever. Even after we're gone.");
+    while (true) {
+        const choice = await p.select({
+            message: "What do you want to do?",
+            options: [
+                {
+                    value: "create",
+                    label: "Create a station",
+                    hint: "pick genre, sync music",
+                },
+                {
+                    value: "sync",
+                    label: "Sync music",
+                    hint: "upload tracks to your station",
+                },
+                {
+                    value: "connect",
+                    label: "Connect speaker",
+                    hint: "link your OpenHome device",
+                },
+                { value: "list", label: "List stations", hint: "browse the network" },
+                {
+                    value: "status",
+                    label: "Check status",
+                    hint: "relay, speaker, wallet",
+                },
+                { value: "exit", label: "Exit" },
+            ],
+        });
+        if (isCancel(choice) || choice === "exit") {
+            p.outro("Signing off.");
+            process.exit(0);
+        }
+        switch (choice) {
+            case "create":
+                await handleCreate();
+                break;
+            case "sync":
+                await handleSync();
+                break;
+            case "connect":
+                await handleConnect();
+                break;
+            case "list":
+                await handleList();
+                break;
+            case "status":
+                await handleStatus();
+                break;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Option 1 — Create a station
+// ---------------------------------------------------------------------------
+async function handleCreate() {
+    // Station name
+    const rawName = await p.text({
+        message: "Station name",
+        placeholder: "My Pirate Radio",
+        validate: (val) => {
+            if (!val || !val.trim())
+                return "Station name is required.";
+        },
+    });
+    guardCancel(rawName);
+    const stationName = rawName.trim();
+    // Genre picker
+    const genre = await p.select({
+        message: "Genre",
+        options: [
+            { value: "Talk", label: "Talk" },
+            { value: "Music", label: "Music" },
+            { value: "Live DJ", label: "Live DJ" },
+            { value: "Other", label: "Other" },
+        ],
+    });
+    guardCancel(genre);
+    // On-chain registration
+    p.note(`Your station needs to be registered on Base so others can find it.\nOpening https://deadman.fm/create in your browser...`, "On-chain registration");
+    try {
+        const opener = process.platform === "darwin"
+            ? "open"
+            : process.platform === "win32"
+                ? "start"
+                : "xdg-open";
+        execSync(`${opener} "https://deadman.fm/create?name=${encodeURIComponent(stationName)}&genre=${encodeURIComponent(genre)}" 2>/dev/null`);
+    }
+    catch {
+        p.log.warn(`Visit: https://deadman.fm/create\nName: ${stationName}  Genre: ${genre}`);
+    }
+    const stationIdRaw = await p.text({
+        message: "Station ID from the page (leave blank to skip)",
+        placeholder: "42",
+    });
+    guardCancel(stationIdRaw);
+    const stationIdParsed = stationIdRaw
+        ? parseInt(stationIdRaw, 10)
+        : NaN;
+    const stationId = !isNaN(stationIdParsed) ? stationIdParsed : null;
+    if (stationId !== null) {
+        p.log.success(`Station #${stationId} created — "${stationName}" (${genre})`);
+    }
+    else {
+        p.log.success(`Station "${stationName}" ready.`);
+        p.log.info("Run Sync music once your on-chain tx confirms.");
+    }
+    // Auto-flow into sync
+    const goSync = await p.confirm({
+        message: "Sync music to this station now?",
+        initialValue: true,
+    });
+    guardCancel(goSync);
+    if (goSync) {
+        await handleSyncForStation(stationName, stationId);
+    }
+    else {
+        p.log.info("Pick Sync music any time to upload tracks.");
+    }
+}
+// ---------------------------------------------------------------------------
+// Option 2 — Sync music (standalone entry point)
+// ---------------------------------------------------------------------------
+async function handleSync() {
+    const stations = loadLocalStations();
+    if (stations.length === 0) {
+        p.log.warn("No local stations found. Create one first.");
+        return;
+    }
+    let stationName;
+    let stationId = null;
+    if (stations.length === 1) {
+        stationName = stations[0].meta.name;
+        stationId = stations[0].meta.stationId ?? null;
+        p.log.info(`Using station: ${stationName}`);
+    }
+    else {
+        const selected = await p.select({
+            message: "Which station?",
+            options: stations.map(({ meta }) => ({
+                value: meta.name,
+                label: meta.name,
+                hint: meta.stationId !== undefined
+                    ? `#${meta.stationId} · ${meta.genre}`
+                    : meta.genre,
+            })),
+        });
+        guardCancel(selected);
+        const found = stations.find((s) => s.meta.name === selected);
+        stationName = found?.meta.name ?? selected;
+        stationId = found?.meta.stationId ?? null;
+    }
+    await handleSyncForStation(stationName, stationId);
+}
+// ---------------------------------------------------------------------------
+// Shared sync logic
+// ---------------------------------------------------------------------------
+async function handleSyncForStation(stationName, stationId) {
+    const idLabel = stationId !== null ? `#${stationId}` : `"${stationName}"`;
+    const rawPath = await p.text({
+        message: "Path to music folder",
+        placeholder: "~/Music",
+        validate: (val) => {
+            if (!val || !val.trim())
+                return "Path is required.";
+        },
+    });
+    guardCancel(rawPath);
+    const musicPath = rawPath.trim().replace(/^~/, homedir());
+    if (!existsSync(musicPath)) {
+        p.log.error(`Folder not found: ${musicPath}`);
+        return;
+    }
+    // Scan
+    const scanSpinner = p.spinner();
+    scanSpinner.start("Scanning folder...");
+    const tracks = scanMusicFolder(musicPath);
+    scanSpinner.stop(`Found ${tracks.length} track${tracks.length === 1 ? "" : "s"}`);
+    if (tracks.length === 0) {
+        p.log.warn("No audio files found (mp3, flac, wav, ogg, m4a, aac, opus).");
+        return;
+    }
+    // Summary
+    const artistSet = new Set(tracks.map((t) => t.artist).filter(Boolean));
+    const artistCount = artistSet.size || 1;
+    const MAX_DISPLAY = 20;
+    const shown = tracks.slice(0, MAX_DISPLAY);
+    const trackLines = shown
+        .map((t) => {
+        const parts = [t.artist, t.album, t.title].filter(Boolean);
+        return parts.length > 0 ? parts.join(" — ") : basename(t.relativePath);
+    })
+        .join("\n");
+    const overflow = tracks.length > MAX_DISPLAY
+        ? `\n… and ${tracks.length - MAX_DISPLAY} more`
+        : "";
+    p.note(`${tracks.length} track${tracks.length === 1 ? "" : "s"} by ${artistCount} artist${artistCount === 1 ? "" : "s"}\n\n${trackLines}${overflow}`, "Tracks found");
+    const go = await p.confirm({
+        message: `Sync ${tracks.length} tracks to station ${idLabel}?`,
+        initialValue: true,
+    });
+    guardCancel(go);
+    if (!go) {
+        p.log.info("Cancelled.");
+        return;
+    }
+    const syncSpinner = p.spinner();
+    syncSpinner.start(`Syncing ${tracks.length} tracks to ${idLabel}...`);
+    const { createStation } = await import("./create.js");
+    const stations = loadLocalStations();
+    const found = stations.find((s) => s.meta.name === stationName ||
+        (stationId !== null && s.meta.stationId === stationId));
+    const genre = found?.meta.genre ?? "Electronic";
+    const originalLog = console.log;
+    let totalSegments = 0;
+    let currentTrackIdx = 0;
+    console.log = (...args) => {
+        const msg = args.map((a) => String(a)).join(" ");
+        if (msg.includes("📀")) {
+            currentTrackIdx++;
+            const pct = Math.round((currentTrackIdx / tracks.length) * 100);
+            const label = msg.replace(/\s*📀\s*/, "").trim();
+            syncSpinner.message(`[${pct}%] 📀 ${label}`);
+        }
+        else if (msg.includes("→") && msg.includes("segments")) {
+            const match = msg.match(/(\d+)\s+segments/);
+            if (match) {
+                totalSegments += parseInt(match[1], 10);
+            }
+        }
+        // suppress other createStation output
+    };
+    try {
+        await createStation({
+            name: stationName,
+            genre,
+            music: musicPath,
+            watch: false,
+        });
+    }
+    catch (err) {
+        console.log = originalLog;
+        const message = err instanceof Error ? err.message : String(err);
+        syncSpinner.stop("Sync failed.");
+        p.log.error(`Error during sync: ${message}`);
+        return;
+    }
+    console.log = originalLog;
+    syncSpinner.stop(`Station ${idLabel} is live. ${totalSegments} segments on the network.`);
+    p.log.info("Press Ctrl+C to stop seeding.");
+    // Keep alive — seeding runs inside createStation's swarm
+    await new Promise(() => { });
+}
+// ---------------------------------------------------------------------------
+// Option 3 — Connect to speaker
+// ---------------------------------------------------------------------------
+async function handleConnect() {
+    p.note('This links your Mac to your OpenHome speaker over WebSocket.\nOnce connected, say "deadman radio" on your speaker to control stations.', "Connect speaker");
+    let apiKey = await loadApiKey();
+    if (apiKey) {
+        p.log.success("Using saved API key from Keychain.");
+    }
+    else {
+        p.log.info("Get your API key at app.openhome.com → Settings → API Keys");
+        const rawKey = await p.text({
+            message: "OpenHome API key",
+            validate: (val) => {
+                if (!val || !val.trim())
+                    return "API key is required.";
+            },
+        });
+        guardCancel(rawKey);
+        apiKey = rawKey.trim();
+        const save = await p.confirm({
+            message: "Save to Keychain so you don't need to enter it again?",
+            initialValue: true,
+        });
+        guardCancel(save);
+        if (save) {
+            await saveApiKey(apiKey);
+            p.log.success("Saved to Keychain.");
+        }
+    }
+    const connectSpinner = p.spinner();
+    connectSpinner.start("Starting Local Link bridge...");
+    const { startLocalLink } = await import("./local-link.js");
+    connectSpinner.stop('Speaker ↔ Mac bridge active. Say "deadman radio" on your speaker.');
+    p.log.info("Press Ctrl+C to stop.");
+    await startLocalLink(apiKey);
+}
+// ---------------------------------------------------------------------------
+// Option 4 — List stations on the network
+// ---------------------------------------------------------------------------
+async function handleList() {
+    const localStations = loadLocalStations();
+    const localNames = new Set(localStations.map((s) => s.meta.name));
+    const { createPublicClient, http, parseAbiItem } = await import("viem");
+    const { base } = await import("viem/chains");
+    const REGISTRY = "0x3b9b6c9BBa15173ba4EF544c17Cb2Ba969d8b585";
+    const DEPLOY_BLOCK = 43856547n;
+    const client = createPublicClient({
+        chain: base,
+        transport: http("https://mainnet.base.org"),
+    });
+    const event = parseAbiItem("event StationCreated(uint256 indexed stationId, address indexed creator, string name, bytes32 genre, bytes32 hypercorePubKey, address curve)");
+    const listSpinner = p.spinner();
+    listSpinner.start("Fetching stations from Base chain...");
+    let logs;
+    try {
+        const CHUNK = 9500n;
+        const currentBlock = await client.getBlockNumber();
+        const allLogs = [];
+        let from = DEPLOY_BLOCK;
+        while (from <= currentBlock) {
+            const to = from + CHUNK > currentBlock ? currentBlock : from + CHUNK;
+            const chunk = (await client.getLogs({
+                address: REGISTRY,
+                event,
+                fromBlock: from,
+                toBlock: to,
+            }));
+            allLogs.push(...chunk);
+            from = to + 1n;
+        }
+        logs = allLogs;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        listSpinner.stop("Failed.");
+        p.log.error(`Could not reach Base chain: ${message}`);
+        return;
+    }
+    listSpinner.stop(`Found ${logs.length} station${logs.length === 1 ? "" : "s"} on Base`);
+    if (logs.length === 0) {
+        p.log.info("No stations yet. Run Create a station to be the first.");
+        return;
+    }
+    const lines = [];
+    for (const log of logs) {
+        const args = log.args;
+        const id = args.stationId?.toString() ?? "?";
+        const name = args.name ?? "Unnamed";
+        const creator = args.creator ?? "0x???";
+        const genre = args.genre
+            ? Buffer.from(args.genre.replace(/^0x/, ""), "hex")
+                .toString("utf8")
+                .replace(/\0/g, "")
+            : "Other";
+        const isMine = localNames.has(name);
+        const star = isMine ? " ★" : "";
+        const shortAddr = `${creator.slice(0, 6)}…${creator.slice(-4)}`;
+        lines.push(`#${id}  ${name}${star}\n   ${genre}  ·  ${shortAddr}`);
+    }
+    const footer = localNames.size > 0
+        ? `${logs.length} station${logs.length === 1 ? "" : "s"} total  ·  ★ = your station`
+        : `${logs.length} station${logs.length === 1 ? "" : "s"} total`;
+    p.note(lines.join("\n\n"), footer);
+}
+// ---------------------------------------------------------------------------
+// Option 5 — Status
+// ---------------------------------------------------------------------------
+async function handleStatus() {
+    const statusSpinner = p.spinner();
+    statusSpinner.start("Checking status...");
+    const relayUp = checkRelay();
+    const linkUp = checkLocalLink();
+    const stations = loadLocalStations();
+    const wallet = loadSavedWallet();
+    const apiKey = await loadApiKey();
+    statusSpinner.stop("Status");
+    const relayLine = `Relay (localhost:4040)   ${relayUp ? "running" : "not running"}`;
+    const linkLine = `Speaker bridge          ${linkUp ? "connected" : "not running"}`;
+    let stationLines;
+    if (stations.length === 0) {
+        stationLines = "Stations seeding         none";
+    }
+    else {
+        const detail = stations
+            .map(({ meta }) => {
+            const idStr = meta.stationId !== undefined ? ` #${meta.stationId}` : "";
+            return `  · ${meta.name}${idStr}  (${meta.totalSegments} segments)`;
+        })
+            .join("\n");
+        stationLines = `Local stations           ${stations.length}\n${detail}`;
+    }
+    const walletLine = wallet
+        ? `Wallet                   ${wallet.slice(0, 6)}…${wallet.slice(-4)}`
+        : "Wallet                   not saved";
+    const apiLine = `OpenHome API key         ${apiKey ? "saved" : "not saved"}`;
+    p.note([relayLine, linkLine, stationLines, walletLine, apiLine].join("\n"), "System status");
+}

package/dist/commands/list.d.ts

@@ -0,0 +1,4 @@
+/**
+ * deadman list — List all stations from Base chain
+ */
+export declare function listStations(): Promise<void>;

package/dist/commands/list.js

@@ -0,0 +1,50 @@
+/**
+ * deadman list — List all stations from Base chain
+ */
+import { createPublicClient, http, parseAbiItem } from "viem";
+import { base } from "viem/chains";
+const REGISTRY = "0x3b9b6c9BBa15173ba4EF544c17Cb2Ba969d8b585";
+const DEPLOY_BLOCK = 43856547n;
+const client = createPublicClient({
+    chain: base,
+    transport: http("https://mainnet.base.org"),
+});
+const event = parseAbiItem("event StationCreated(uint256 indexed stationId, address indexed creator, string name, bytes32 genre, bytes32 hypercorePubKey, address curve)");
+export async function listStations() {
+    console.log("💀 Fetching stations from Base chain...\n");
+    // Base RPC limits eth_getLogs to 10,000 blocks. Paginate.
+    const CHUNK = 9500n;
+    const currentBlock = await client.getBlockNumber();
+    const allLogs = [];
+    let from = DEPLOY_BLOCK;
+    while (from <= currentBlock) {
+        const to = from + CHUNK > currentBlock ? currentBlock : from + CHUNK;
+        const chunk = await client.getLogs({
+            address: REGISTRY,
+            event,
+            fromBlock: from,
+            toBlock: to,
+        });
+        allLogs.push(...chunk);
+        from = to + 1n;
+    }
+    const logs = allLogs;
+    if (logs.length === 0) {
+        console.log('   No stations yet. Be the first: deadman create --name "My Station" --genre Electronic --music ~/Music/');
+        return;
+    }
+    for (const log of logs) {
+        const id = log.args.stationId?.toString() ?? "?";
+        const name = log.args.name ?? "Unnamed";
+        const creator = log.args.creator ?? "0x?";
+        const genre = log.args.genre
+            ? Buffer.from(log.args.genre.replace(/^0x/, ""), "hex")
+                .toString("utf8")
+                .replace(/\0/g, "")
+            : "Other";
+        console.log(`   #${id}  ${name}`);
+        console.log(`         ${genre} · ${creator.slice(0, 6)}…${creator.slice(-4)}`);
+        console.log();
+    }
+    console.log(`   ${logs.length} station(s) total`);
+}

package/dist/commands/local-link.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Local Link bridge — connects your OpenHome speaker to your Mac
+ *
+ * WebSocket client that receives commands from the speaker's ability
+ * and executes them locally. This is how "sync" works.
+ */
+export declare function startLocalLink(apiKey: string): Promise<void>;

package/dist/commands/local-link.js

@@ -0,0 +1,71 @@
+/**
+ * Local Link bridge — connects your OpenHome speaker to your Mac
+ *
+ * WebSocket client that receives commands from the speaker's ability
+ * and executes them locally. This is how "sync" works.
+ */
+import { execSync } from "node:child_process";
+import WebSocket from "ws";
+export async function startLocalLink(apiKey) {
+    const host = "app.openhome.com";
+    const port = 8769;
+    const clientId = "deadman-cli";
+    const role = "agent";
+    const url = `ws://${host}:${port}/?api_key=${apiKey}&client_id=${clientId}&role=${role}`;
+    console.log(`💀 Connecting to OpenHome...`);
+    const ws = new WebSocket(url);
+    ws.on("open", () => {
+        console.log("💀 Connected. Speaker ↔ Mac bridge active.");
+        console.log("   Waiting for commands from your speaker...\n");
+    });
+    ws.on("message", (raw) => {
+        const msg = raw.toString();
+        let data;
+        try {
+            data = JSON.parse(msg);
+        }
+        catch {
+            return;
+        }
+        const type = data.type;
+        if (type === "ping") {
+            ws.send(JSON.stringify({ type: "pong" }));
+            return;
+        }
+        if (type === "command" || type === "relay") {
+            const payload = data.data;
+            const command = typeof payload === "object" ? payload.cmd : String(payload || "");
+            if (!command)
+                return;
+            console.log(`   📡 Command: ${command}`);
+            try {
+                const stdout = execSync(command, {
+                    timeout: 30000,
+                    encoding: "utf8",
+                    maxBuffer: 1024 * 1024,
+                });
+                console.log(`   ✅ Done`);
+                ws.send(JSON.stringify({
+                    type: "response",
+                    data: { ok: true, returncode: 0, stdout, stderr: "" },
+                }));
+            }
+            catch (err) {
+                console.log(`   ❌ Failed: ${err.message?.slice(0, 100)}`);
+                ws.send(JSON.stringify({
+                    type: "response",
+                    data: { ok: false, error: err.message },
+                }));
+            }
+        }
+    });
+    ws.on("error", (err) => {
+        console.error(`💀 Connection error: ${err.message}`);
+    });
+    ws.on("close", () => {
+        console.log("💀 Disconnected. Reconnecting in 5s...");
+        setTimeout(() => startLocalLink(apiKey), 5000);
+    });
+    // Keep alive
+    await new Promise(() => { });
+}

package/dist/commands/seed.d.ts

@@ -0,0 +1,6 @@
+/**
+ * deadman seed — Join swarm and serve an existing station's content
+ */
+export declare function seedStation(opts: {
+    station: string;
+}): Promise<void>;

package/dist/commands/seed.js

@@ -0,0 +1,65 @@
+/**
+ * deadman seed — Join swarm and serve an existing station's content
+ */
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { readdirSync, readFileSync } from "node:fs";
+import Hypercore from "hypercore";
+import Hyperswarm from "hyperswarm";
+export async function seedStation(opts) {
+    const stationsDir = join(homedir(), ".deadman-fm", "stations");
+    // Find station by ID or name
+    let stationDir = null;
+    let meta = null;
+    try {
+        const dirs = readdirSync(stationsDir);
+        for (const dir of dirs) {
+            const metaPath = join(stationsDir, dir, "station.json");
+            try {
+                const m = JSON.parse(readFileSync(metaPath, "utf8"));
+                if (dir === opts.station ||
+                    m.name === opts.station ||
+                    String(m.stationId) === opts.station) {
+                    stationDir = join(stationsDir, dir);
+                    meta = m;
+                    break;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch {
+        console.error("❌ No stations found. Create one first: deadman create ...");
+        process.exit(1);
+    }
+    if (!stationDir || !meta) {
+        console.error(`❌ Station "${opts.station}" not found`);
+        process.exit(1);
+    }
+    console.log(`💀 Seeding: ${meta.name}`);
+    console.log(`   ${meta.totalSegments} segments`);
+    const feedPath = join(stationDir, "feed");
+    const core = new Hypercore(feedPath);
+    await core.ready();
+    console.log(`   Feed: ${core.key.toString("hex").slice(0, 16)}...`);
+    console.log(`   Length: ${core.length} blocks`);
+    const swarm = new Hyperswarm();
+    let peerCount = 0;
+    swarm.on("connection", (socket) => {
+        peerCount++;
+        console.log(`   🔗 Peer connected (${peerCount} total)`);
+        core.replicate(socket);
+        socket.on("close", () => {
+            peerCount--;
+            console.log(`   💤 Peer disconnected (${peerCount} total)`);
+        });
+    });
+    swarm.join(core.discoveryKey, { server: true, client: true });
+    await swarm.flush();
+    console.log(`\n💀 Seeding "${meta.name}" on the network`);
+    console.log(`   Press Ctrl+C to stop\n`);
+    // Keep alive
+    await new Promise(() => { });
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * 💀.fm CLI — Decentralized pirate radio
+ *
+ * Run with no arguments for interactive menu.
+ * Or use commands directly:
+ *   deadman create --name "Station" --genre Electronic --music ~/Music/
+ *   deadman list
+ *   deadman seed --station 0
+ *   deadman connect
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+/**
+ * 💀.fm CLI — Decentralized pirate radio
+ *
+ * Run with no arguments for interactive menu.
+ * Or use commands directly:
+ *   deadman create --name "Station" --genre Electronic --music ~/Music/
+ *   deadman list
+ *   deadman seed --station 0
+ *   deadman connect
+ */
+import { Command } from "commander";
+import { createStation } from "./commands/create.js";
+import { listStations } from "./commands/list.js";
+import { seedStation } from "./commands/seed.js";
+import { interactive } from "./commands/interactive.js";
+const program = new Command();
+program
+    .name("deadman")
+    .description("💀.fm — Decentralized pirate radio")
+    .version("0.1.0");
+program
+    .command("create")
+    .description("Create a new radio station")
+    .requiredOption("--name <name>", "Station name")
+    .requiredOption("--genre <genre>", "Genre")
+    .requiredOption("--music <path>", "Path to audio files folder")
+    .option("--watch", "Watch folder for new files")
+    .action(createStation);
+program
+    .command("seed")
+    .description("Seed an existing station")
+    .requiredOption("--station <id>", "Station ID")
+    .action(seedStation);
+program.command("list").description("List all stations").action(listStations);
+program
+    .command("connect")
+    .description("Connect to your OpenHome speaker")
+    .action(async () => {
+    const { startLocalLink } = await import("./commands/local-link.js");
+    const readline = await import("node:readline");
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const key = await new Promise((r) => rl.question("OpenHome API key: ", r));
+    rl.close();
+    await startLocalLink(key.trim());
+});
+// No arguments = interactive mode
+if (process.argv.length <= 2) {
+    interactive();
+}
+else {
+    program.parse();
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "deadman-fm",
+  "version": "0.1.1",
+  "description": "💀.fm — Create and seed decentralized radio stations",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "deadman-fm": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node src/index.js"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.1.0",
+    "@types/ws": "^8.18.1",
+    "chokidar": "^4.0.0",
+    "commander": "^13.0.0",
+    "fluent-ffmpeg": "^2.1.3",
+    "hypercore": "^11.27.0",
+    "hyperswarm": "^4.9.0",
+    "viem": "^2.23.0",
+    "ws": "^8.20.0"
+  },
+  "devDependencies": {
+    "@types/fluent-ffmpeg": "^2.1.27",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  }
+}