@rocksky/cli 0.1.1 → 0.2.0

package/dist/index.js

@@ -4,9 +4,12 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import fs$1 from 'fs/promises';
-import md5 from 'md5';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
 import dayjs from 'dayjs';
 import relative from 'dayjs/plugin/relativeTime.js';
+import md5 from 'md5';
 import { table, getBorderCharacters } from 'table';
 import { Command } from 'commander';
 import axios from 'axios';
@@ -298,7 +301,7 @@ class RockskyClient {
   }
 }
 
-async function albums(did, { skip, limit }) {
+async function albums$1(did, { skip, limit }) {
   const client = new RockskyClient();
   const albums2 = await client.getAlbums(did, { skip, limit });
   let rank = 1;
@@ -312,7 +315,7 @@ async function albums(did, { skip, limit }) {
   }
 }
 
-async function artists(did, { skip, limit }) {
+async function artists$1(did, { skip, limit }) {
   const client = new RockskyClient();
   const artists2 = await client.getArtists(did, { skip, limit });
   let rank = 1;
@@ -326,7 +329,7 @@ async function artists(did, { skip, limit }) {
   }
 }
 
-async function createApiKey(name, { description }) {
+async function createApiKey$1(name, { description }) {
   const tokenPath = path.join(os.homedir(), ".rocksky", "token.json");
   try {
     await fs$1.access(tokenPath);
@@ -363,6 +366,527 @@ async function createApiKey(name, { description }) {
   console.log(`Secret: ${chalk.greenBright(apikey.shared_secret)}`);
 }
 
+async function albums(did, { skip, limit = 20 }) {
+  const client = new RockskyClient();
+  const albums2 = await client.getAlbums(did, { skip, limit });
+  let rank = 1;
+  let response = `Top ${limit} albums:
+`;
+  for (const album of albums2) {
+    response += `${rank} ${album.title} - ${album.artist} - ${album.play_count} plays
+`;
+    rank++;
+  }
+  return response;
+}
+
+async function artists(did, { skip, limit = 20 }) {
+  try {
+    const client = new RockskyClient();
+    const artists2 = await client.getArtists(did, { skip, limit });
+    let rank = 1;
+    let response = `Top ${limit} artists:
+`;
+    for (const artist of artists2) {
+      response += `${rank} ${artist.name} - ${artist.play_count} plays
+`;
+      rank++;
+    }
+    return response;
+  } catch (err) {
+    return `Failed to fetch artists data. Please check your token and try again, error: ${err.message}`;
+  }
+}
+
+async function createApiKey(name, { description }) {
+  const tokenPath = path.join(os.homedir(), ".rocksky", "token.json");
+  try {
+    await fs$1.access(tokenPath);
+  } catch (err) {
+    return "You are not logged in. Please run `rocksky login <username>.bsky.social` first.";
+  }
+  const tokenData = await fs$1.readFile(tokenPath, "utf-8");
+  const { token } = JSON.parse(tokenData);
+  if (!token) {
+    return "You are not logged in. Please run `rocksky login <username>.bsky.social` first.";
+  }
+  const client = new RockskyClient(token);
+  const apikey = await client.createApiKey(name, description);
+  if (!apikey) {
+    return "Failed to create API key. Please try again later.";
+  }
+  return "API key created successfully!, navigate to your Rocksky account to view it.";
+}
+
+dayjs.extend(relative);
+async function myscrobbles({ skip, limit }) {
+  const tokenPath = path.join(os.homedir(), ".rocksky", "token.json");
+  try {
+    await fs$1.access(tokenPath);
+  } catch (err) {
+    return "You are not logged in. Please run `rocksky login <username>.bsky.social` first.";
+  }
+  const tokenData = await fs$1.readFile(tokenPath, "utf-8");
+  const { token } = JSON.parse(tokenData);
+  if (!token) {
+    return "You are not logged in. Please run `rocksky login <username>.bsky.social` first.";
+  }
+  const client = new RockskyClient(token);
+  try {
+    const { did } = await client.getCurrentUser();
+    const scrobbles = await client.scrobbles(did, { skip, limit });
+    return JSON.stringify(
+      scrobbles.map((scrobble) => ({
+        title: scrobble.title,
+        artist: scrobble.artist,
+        date: dayjs(scrobble.created_at + "Z").fromNow(),
+        isoDate: scrobble.created_at
+      })),
+      null,
+      2
+    );
+  } catch (err) {
+    return `Failed to fetch scrobbles data. Please check your token and try again, error: ${err.message}`;
+  }
+}
+
+async function nowplaying$1(did) {
+  const tokenPath = path.join(os.homedir(), ".rocksky", "token.json");
+  try {
+    await fs$1.access(tokenPath);
+  } catch (err) {
+    if (!did) {
+      return "You are not logged in. Please run `rocksky login <username>.bsky.social` first.";
+    }
+  }
+  const tokenData = await fs$1.readFile(tokenPath, "utf-8");
+  const { token } = JSON.parse(tokenData);
+  if (!token && !did) {
+    return "You are not logged in. Please run `rocksky login <username>.bsky.social` first.";
+  }
+  const client = new RockskyClient(token);
+  try {
+    const nowPlaying = await client.getSpotifyNowPlaying(did);
+    if (!nowPlaying || Object.keys(nowPlaying).length === 0) {
+      const nowPlaying2 = await client.getNowPlaying(did);
+      if (!nowPlaying2 || Object.keys(nowPlaying2).length === 0) {
+        return "No track is currently playing.";
+      }
+      return JSON.stringify(
+        {
+          title: nowPlaying2.title,
+          artist: nowPlaying2.artist,
+          album: nowPlaying2.album
+        },
+        null,
+        2
+      );
+    }
+    return JSON.stringify(
+      {
+        title: nowPlaying.item.name,
+        artist: nowPlaying.item.artists.map((a) => a.name).join(", "),
+        album: nowPlaying.item.album.name
+      },
+      null,
+      2
+    );
+  } catch (err) {
+    return `Failed to fetch now playing data. Please check your token and try again, error: ${err.message}`;
+  }
+}
+
+dayjs.extend(relative);
+async function scrobbles$1(did, { skip, limit }) {
+  try {
+    const client = new RockskyClient();
+    const scrobbles2 = await client.scrobbles(did, { skip, limit });
+    if (did) {
+      return JSON.stringify(
+        scrobbles2.map((scrobble) => ({
+          title: scrobble.title,
+          artist: scrobble.artist,
+          date: dayjs(scrobble.created_at + "Z").fromNow(),
+          isoDate: scrobble.created_at
+        })),
+        null,
+        2
+      );
+    }
+    return JSON.stringify(
+      scrobbles2.map((scrobble) => ({
+        user: `@${scrobble.user}`,
+        title: scrobble.title,
+        artist: scrobble.artist,
+        date: dayjs(scrobble.date).fromNow(),
+        isoDate: scrobble.date
+      })),
+      null,
+      2
+    );
+  } catch (err) {
+    return `Failed to fetch scrobbles data. Please check your token and try again, error: ${err.message}`;
+  }
+}
+
+async function search$1(query, { limit = 20, albums = false, artists = false, tracks = false, users = false }) {
+  const client = new RockskyClient();
+  const results = await client.search(query, { size: limit });
+  if (results.records.length === 0) {
+    return `No results found for ${query}.`;
+  }
+  let mergedResults = results.records.map((record) => ({
+    ...record,
+    type: record.table
+  }));
+  if (albums) {
+    mergedResults = mergedResults.filter((record) => record.table === "albums");
+  }
+  if (artists) {
+    mergedResults = mergedResults.filter(
+      (record) => record.table === "artists"
+    );
+  }
+  if (tracks) {
+    mergedResults = mergedResults.filter(({ table }) => table === "tracks");
+  }
+  if (users) {
+    mergedResults = mergedResults.filter(({ table }) => table === "users");
+  }
+  mergedResults.sort((a, b) => b.xata_score - a.xata_score);
+  const responses = [];
+  for (const { table, record } of mergedResults) {
+    if (table === "users") {
+      responses.push({
+        handle: record.handle,
+        display_name: record.display_name,
+        did: record.did,
+        link: `https://rocksky.app/profile/${record.did}`,
+        type: "account"
+      });
+    }
+    if (table === "albums") {
+      const link = record.uri ? `https://rocksky.app/${record.uri?.split("at://")[1]}` : "";
+      responses.push({
+        title: record.title,
+        artist: record.artist,
+        link,
+        type: "album"
+      });
+    }
+    if (table === "tracks") {
+      const link = record.uri ? `https://rocksky.app/${record.uri?.split("at://")[1]}` : "";
+      responses.push({
+        title: record.title,
+        artist: record.artist,
+        link,
+        type: "track"
+      });
+    }
+    if (table === "artists") {
+      const link = record.uri ? `https://rocksky.app/${record.uri?.split("at://")[1]}` : "";
+      responses.push({
+        name: record.name,
+        link,
+        type: "artist"
+      });
+    }
+  }
+  return JSON.stringify(responses, null, 2);
+}
+
+async function stats$1(did) {
+  const tokenPath = path.join(os.homedir(), ".rocksky", "token.json");
+  try {
+    await fs$1.access(tokenPath);
+  } catch (err) {
+    if (!did) {
+      return "You are not logged in. Please run `rocksky login <username>.bsky.social` first.";
+    }
+  }
+  const tokenData = await fs$1.readFile(tokenPath, "utf-8");
+  const { token } = JSON.parse(tokenData);
+  if (!token && !did) {
+    return "You are not logged in. Please run `rocksky login <username>.bsky.social` first.";
+  }
+  try {
+    const client = new RockskyClient(token);
+    const stats2 = await client.stats(did);
+    return JSON.stringify(
+      {
+        scrobbles: stats2.scrobbles,
+        tracks: stats2.tracks,
+        albums: stats2.albums,
+        artists: stats2.artists,
+        lovedTracks: stats2.lovedTracks
+      },
+      null,
+      2
+    );
+  } catch (err) {
+    return `Failed to fetch stats data. Please check your token and try again, error: ${err.message}`;
+  }
+}
+
+async function tracks$1(did, { skip, limit = 20 }) {
+  const client = new RockskyClient();
+  const tracks2 = await client.getTracks(did, { skip, limit });
+  let rank = 1;
+  let response = `Top ${limit} tracks:
+`;
+  for (const track of tracks2) {
+    response += `${rank} ${track.title} - ${track.artist} - ${track.play_count} plays
+`;
+    rank++;
+  }
+  return response;
+}
+
+async function whoami$1() {
+  const tokenPath = path.join(os.homedir(), ".rocksky", "token.json");
+  try {
+    await fs$1.access(tokenPath);
+  } catch (err) {
+    return "You are not logged in. Please run `rocksky login <username>.bsky.social` first.";
+  }
+  const tokenData = await fs$1.readFile(tokenPath, "utf-8");
+  const { token } = JSON.parse(tokenData);
+  if (!token) {
+    return "You are not logged in. Please run `rocksky login <username>.bsky.social` first.";
+  }
+  const client = new RockskyClient(token);
+  try {
+    const user = await client.getCurrentUser();
+    return `You are logged in as ${user.handle} (${user.displayName}).
+View your profile at: https://rocksky.app/profile/${user.handle}`;
+  } catch (err) {
+    return "Failed to fetch user data. Please check your token and try again.";
+  }
+}
+
+class RockskyMcpServer {
+  server;
+  client;
+  constructor() {
+    this.server = new McpServer({
+      name: "rocksky-mcp",
+      version: "0.1.0"
+    });
+    this.setupTools();
+  }
+  setupTools() {
+    this.server.tool("whoami", "get the current logged-in user.", async () => {
+      return {
+        content: [
+          {
+            type: "text",
+            text: await whoami$1()
+          }
+        ]
+      };
+    });
+    this.server.tool(
+      "nowplaying",
+      "get the currently playing track.",
+      {
+        did: z.string().optional().describe(
+          "the DID or handle of the user to get the now playing track for."
+        )
+      },
+      async ({ did }) => {
+        return {
+          content: [
+            {
+              type: "text",
+              text: await nowplaying$1(did)
+            }
+          ]
+        };
+      }
+    );
+    this.server.tool(
+      "scrobbles",
+      "display recently played tracks (recent scrobbles).",
+      {
+        did: z.string().optional().describe("the DID or handle of the user to get the scrobbles for."),
+        skip: z.number().optional().describe("number of scrobbles to skip"),
+        limit: z.number().optional().describe("number of scrobbles to limit")
+      },
+      async ({ did, skip = 0, limit = 10 }) => {
+        return {
+          content: [
+            {
+              type: "text",
+              text: await scrobbles$1(did, { skip, limit })
+            }
+          ]
+        };
+      }
+    );
+    this.server.tool(
+      "my-scrobbles",
+      "display my recently played tracks (recent scrobbles).",
+      {
+        skip: z.number().optional().describe("number of scrobbles to skip"),
+        limit: z.number().optional().describe("number of scrobbles to limit")
+      },
+      async ({ skip = 0, limit = 10 }) => {
+        return {
+          content: [
+            {
+              type: "text",
+              text: await myscrobbles({ skip, limit })
+            }
+          ]
+        };
+      }
+    );
+    this.server.tool(
+      "search",
+      "search for tracks, artists, albums or users.",
+      {
+        query: z.string().describe("the search query, e.g., artist, album, title or account"),
+        limit: z.number().optional().describe("number of results to limit"),
+        albums: z.boolean().optional().describe("search for albums"),
+        tracks: z.boolean().optional().describe("search for tracks"),
+        users: z.boolean().optional().describe("search for users"),
+        artists: z.boolean().optional().describe("search for artists")
+      },
+      async ({
+        query,
+        limit = 10,
+        albums: albums2 = false,
+        tracks: tracks2 = false,
+        users = false,
+        artists: artists2 = false
+      }) => {
+        return {
+          content: [
+            {
+              type: "text",
+              text: await search$1(query, {
+                limit,
+                albums: albums2,
+                tracks: tracks2,
+                users,
+                artists: artists2
+              })
+            }
+          ]
+        };
+      }
+    );
+    this.server.tool(
+      "artists",
+      "get the user's top artists or current user's artists if no did is provided.",
+      {
+        did: z.string().optional().describe("the DID or handle of the user to get artists for."),
+        limit: z.number().optional().describe("number of results to limit")
+      },
+      async ({ did, limit }) => {
+        return {
+          content: [
+            {
+              type: "text",
+              text: await artists(did, { skip: 0, limit })
+            }
+          ]
+        };
+      }
+    );
+    this.server.tool(
+      "albums",
+      "get the user's top albums or current user's albums if no did is provided.",
+      {
+        did: z.string().optional().describe("the DID or handle of the user to get albums for."),
+        limit: z.number().optional().describe("number of results to limit")
+      },
+      async ({ did, limit }) => {
+        return {
+          content: [
+            {
+              type: "text",
+              text: await albums(did, { skip: 0, limit })
+            }
+          ]
+        };
+      }
+    );
+    this.server.tool(
+      "tracks",
+      "get the user's top tracks or current user's tracks if no did is provided.",
+      {
+        did: z.string().optional().describe("the DID or handle of the user to get tracks for."),
+        limit: z.number().optional().describe("number of results to limit")
+      },
+      async ({ did, limit }) => {
+        return {
+          content: [
+            {
+              type: "text",
+              text: await tracks$1(did, { skip: 0, limit })
+            }
+          ]
+        };
+      }
+    );
+    this.server.tool(
+      "stats",
+      "get the user's listening stats or current user's stats if no did is provided.",
+      {
+        did: z.string().optional().describe("the DID or handle of the user to get stats for.")
+      },
+      async ({ did }) => {
+        return {
+          content: [
+            {
+              type: "text",
+              text: await stats$1(did)
+            }
+          ]
+        };
+      }
+    );
+    this.server.tool(
+      "create-apikey",
+      "create an API key.",
+      {
+        name: z.string().describe("the name of the API key"),
+        description: z.string().optional().describe("the description of the API key")
+      },
+      async ({ name, description }) => {
+        return {
+          content: [
+            {
+              type: "text",
+              text: await createApiKey(name, { description })
+            }
+          ]
+        };
+      }
+    );
+  }
+  async run() {
+    const stdioTransport = new StdioServerTransport();
+    try {
+      await this.server.connect(stdioTransport);
+    } catch (error) {
+      process.exit(1);
+    }
+  }
+  getServer() {
+    return this.server;
+  }
+}
+const rockskyMcpServer = new RockskyMcpServer();
+
+function mcp() {
+  rockskyMcpServer.run().catch((error) => {
+    console.error("Failed to run Rocksky MCP server", { error });
+    process.exit(1);
+  });
+}
+
 async function nowplaying(did) {
   const tokenPath = path.join(os.homedir(), ".rocksky", "token.json");
   try {
@@ -637,7 +1161,7 @@ async function whoami() {
   }
 }
 
-var version = "0.1.0";
+var version = "0.2.0";
 var version$1 = {
 	version: version};
 
@@ -680,7 +1204,9 @@ async function login(handle) {
 
 const program = new Command();
 program.name("rocksky").description(
-  "Command-line interface for Rocksky \u2013 scrobble tracks, view stats, and manage your listening history."
+  `Command-line interface for Rocksky (${chalk.underline(
+    "https://rocksky.app"
+  )}) \u2013 scrobble tracks, view stats, and manage your listening history.`
 ).version(version$1.version);
 program.command("login").argument("<handle>", "your BlueSky handle (e.g., <username>.bsky.social)").description("login with your BlueSky account and get a session token.").action(login);
 program.command("whoami").description("get the current logged-in user.").action(whoami);
@@ -694,9 +1220,10 @@ program.command("search").option("-a, --albums", "search for albums").option("-t
   "the search query, e.g., artist, album, title or account"
 ).description("search for tracks, albums, or accounts.").action(search);
 program.command("stats").option("-l, --limit <number>", "number of results to limit").argument("[did]", "the DID or handle of the user to get stats for.").description("get the user's listening stats.").action(stats);
-program.command("artists").option("-l, --limit <number>", "number of results to limit").argument("[did]", "the DID or handle of the user to get artists for.").description("get the user's top artists.").action(artists);
-program.command("albums").option("-l, --limit <number>", "number of results to limit").argument("[did]", "the DID or handle of the user to get albums for.").description("get the user's top albums.").action(albums);
+program.command("artists").option("-l, --limit <number>", "number of results to limit").argument("[did]", "the DID or handle of the user to get artists for.").description("get the user's top artists.").action(artists$1);
+program.command("albums").option("-l, --limit <number>", "number of results to limit").argument("[did]", "the DID or handle of the user to get albums for.").description("get the user's top albums.").action(albums$1);
 program.command("tracks").option("-l, --limit <number>", "number of results to limit").argument("[did]", "the DID or handle of the user to get tracks for.").description("get the user's top tracks.").action(tracks);
 program.command("scrobble").argument("<track>", "the title of the track").argument("<artist>", "the artist of the track").option("-t, --timestamp <timestamp>", "the timestamp of the scrobble").description("scrobble a track to your profile.").action(scrobble);
-program.command("create").description("create a new API key.").command("apikey").argument("<name>", "the name of the API key").option("-d, --description <description>", "the description of the API key").description("create a new API key.").action(createApiKey);
+program.command("create").description("create a new API key.").command("apikey").argument("<name>", "the name of the API key").option("-d, --description <description>", "the description of the API key").description("create a new API key.").action(createApiKey$1);
+program.command("mcp").description("Starts an MCP server to use with Claude or other LLMs.").action(mcp);
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rocksky/cli",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Command-line interface for Rocksky – scrobble tracks, view stats, and manage your listening history",
   "main": "dist/index.js",
   "type": "module",
@@ -22,6 +22,7 @@
   "author": "Tsiry Sandratraina <tsiry.sndr@rocksky.app>",
   "license": "Apache-2.0",
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.10.2",
     "axios": "^1.8.4",
     "chalk": "^5.4.1",
     "commander": "^13.1.0",
@@ -30,7 +31,8 @@
     "express": "^5.1.0",
     "md5": "^2.3.0",
     "open": "^10.1.0",
-    "table": "^6.9.0"
+    "table": "^6.9.0",
+    "zod": "^3.24.3"
   },
   "devDependencies": {
     "@types/express": "^5.0.1",

package/src/cmd/mcp.ts

@@ -0,0 +1,8 @@
+import { rockskyMcpServer } from "mcp";
+
+export function mcp() {
+  rockskyMcpServer.run().catch((error) => {
+    console.error("Failed to run Rocksky MCP server", { error });
+    process.exit(1);
+  });
+}

package/src/index.ts

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
 
+import chalk from "chalk";
 import { albums } from "cmd/albums";
 import { artists } from "cmd/artists";
 import { createApiKey } from "cmd/create";
+import { mcp } from "cmd/mcp";
 import { nowplaying } from "cmd/nowplaying";
 import { scrobble } from "cmd/scrobble";
 import { scrobbles } from "cmd/scrobbles";
@@ -19,7 +21,9 @@ const program = new Command();
 program
   .name("rocksky")
   .description(
-    "Command-line interface for Rocksky – scrobble tracks, view stats, and manage your listening history."
+    `Command-line interface for Rocksky (${chalk.underline(
+      "https://rocksky.app"
+    )}) – scrobble tracks, view stats, and manage your listening history.`
   )
   .version(version.version);
 
@@ -109,4 +113,9 @@ program
   .description("create a new API key.")
   .action(createApiKey);
 
+program
+  .command("mcp")
+  .description("Starts an MCP server to use with Claude or other LLMs.")
+  .action(mcp);
+
 program.parse(process.argv);