@rocksky/cli 0.1.0 → 0.2.0

package/src/mcp/index.ts

@@ -0,0 +1,269 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { RockskyClient } from "client";
+import { z } from "zod";
+import { albums } from "./tools/albums";
+import { artists } from "./tools/artists";
+import { createApiKey } from "./tools/create";
+import { myscrobbles } from "./tools/myscrobbles";
+import { nowplaying } from "./tools/nowplaying";
+import { scrobbles } from "./tools/scrobbles";
+import { search } from "./tools/search";
+import { stats } from "./tools/stats";
+import { tracks } from "./tools/tracks";
+import { whoami } from "./tools/whoami";
+
+class RockskyMcpServer {
+  private readonly server: McpServer;
+  private readonly client: RockskyClient;
+
+  constructor() {
+    this.server = new McpServer({
+      name: "rocksky-mcp",
+      version: "0.1.0",
+    });
+    const client = new RockskyClient();
+    this.setupTools();
+  }
+
+  private setupTools() {
+    this.server.tool("whoami", "get the current logged-in user.", async () => {
+      return {
+        content: [
+          {
+            type: "text",
+            text: await whoami(),
+          },
+        ],
+      };
+    });
+
+    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(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(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 = false,
+        tracks = false,
+        users = false,
+        artists = false,
+      }) => {
+        return {
+          content: [
+            {
+              type: "text",
+              text: await search(query, {
+                limit,
+                albums,
+                tracks,
+                users,
+                artists,
+              }),
+            },
+          ],
+        };
+      }
+    );
+
+    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(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(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);
+    }
+  }
+
+  public getServer(): McpServer {
+    return this.server;
+  }
+}
+
+export const rockskyMcpServer = new RockskyMcpServer();

package/src/mcp/tools/albums.ts

@@ -0,0 +1,13 @@
+import { RockskyClient } from "client";
+
+export async function albums(did, { skip, limit = 20 }): Promise<string> {
+  const client = new RockskyClient();
+  const albums = await client.getAlbums(did, { skip, limit });
+  let rank = 1;
+  let response = `Top ${limit} albums:\n`;
+  for (const album of albums) {
+    response += `${rank} ${album.title} - ${album.artist} - ${album.play_count} plays\n`;
+    rank++;
+  }
+  return response;
+}

package/src/mcp/tools/artists.ts

@@ -0,0 +1,17 @@
+import { RockskyClient } from "client";
+
+export async function artists(did, { skip, limit = 20 }): Promise<string> {
+  try {
+    const client = new RockskyClient();
+    const artists = await client.getArtists(did, { skip, limit });
+    let rank = 1;
+    let response = `Top ${limit} artists:\n`;
+    for (const artist of artists) {
+      response += `${rank} ${artist.name} - ${artist.play_count} plays\n`;
+      rank++;
+    }
+    return response;
+  } catch (err) {
+    return `Failed to fetch artists data. Please check your token and try again, error: ${err.message}`;
+  }
+}

package/src/mcp/tools/create.ts

@@ -0,0 +1,27 @@
+import { RockskyClient } from "client";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+
+export async function createApiKey(name, { description }) {
+  const tokenPath = path.join(os.homedir(), ".rocksky", "token.json");
+  try {
+    await fs.access(tokenPath);
+  } catch (err) {
+    return "You are not logged in. Please run `rocksky login <username>.bsky.social` first.";
+  }
+
+  const tokenData = await fs.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.";
+}

package/src/mcp/tools/myscrobbles.ts

@@ -0,0 +1,42 @@
+import { RockskyClient } from "client";
+import dayjs from "dayjs";
+import relative from "dayjs/plugin/relativeTime.js";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+
+dayjs.extend(relative);
+
+export async function myscrobbles({ skip, limit }): Promise<string> {
+  const tokenPath = path.join(os.homedir(), ".rocksky", "token.json");
+  try {
+    await fs.access(tokenPath);
+  } catch (err) {
+    return "You are not logged in. Please run `rocksky login <username>.bsky.social` first.";
+  }
+
+  const tokenData = await fs.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}`;
+  }
+}

package/src/mcp/tools/nowplaying.ts

@@ -0,0 +1,53 @@
+import { RockskyClient } from "client";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+
+export async function nowplaying(did?: string): Promise<string> {
+  const tokenPath = path.join(os.homedir(), ".rocksky", "token.json");
+  try {
+    await fs.access(tokenPath);
+  } catch (err) {
+    if (!did) {
+      return "You are not logged in. Please run `rocksky login <username>.bsky.social` first.";
+    }
+  }
+
+  const tokenData = await fs.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 nowPlaying = await client.getNowPlaying(did);
+      if (!nowPlaying || Object.keys(nowPlaying).length === 0) {
+        return "No track is currently playing.";
+      }
+      return JSON.stringify(
+        {
+          title: nowPlaying.title,
+          artist: nowPlaying.artist,
+          album: nowPlaying.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}`;
+  }
+}

package/src/mcp/tools/scrobbles.ts

@@ -0,0 +1,39 @@
+import { RockskyClient } from "client";
+import dayjs from "dayjs";
+import relative from "dayjs/plugin/relativeTime.js";
+
+dayjs.extend(relative);
+
+export async function scrobbles(did, { skip, limit }): Promise<string> {
+  try {
+    const client = new RockskyClient();
+    const scrobbles = await client.scrobbles(did, { skip, limit });
+
+    if (did) {
+      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
+      );
+    }
+
+    return JSON.stringify(
+      scrobbles.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}`;
+  }
+}

package/src/mcp/tools/search.ts

@@ -0,0 +1,88 @@
+import { RockskyClient } from "client";
+
+export async function search(
+  query: string,
+  { limit = 20, albums = false, artists = false, tracks = false, users = false }
+): Promise<string> {
+  const client = new RockskyClient();
+  const results = await client.search(query, { size: limit });
+  if (results.records.length === 0) {
+    return `No results found for ${query}.`;
+  }
+
+  // merge all results into one array with type and sort by xata_scrore
+  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: 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: link,
+        type: "track",
+      });
+    }
+
+    if (table === "artists") {
+      const link = record.uri
+        ? `https://rocksky.app/${record.uri?.split("at://")[1]}`
+        : "";
+      responses.push({
+        name: record.name,
+        link: link,
+        type: "artist",
+      });
+    }
+  }
+
+  return JSON.stringify(responses, null, 2);
+}

package/src/mcp/tools/stats.ts

@@ -0,0 +1,40 @@
+import { RockskyClient } from "client";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+
+export async function stats(did?: string): Promise<string> {
+  const tokenPath = path.join(os.homedir(), ".rocksky", "token.json");
+  try {
+    await fs.access(tokenPath);
+  } catch (err) {
+    if (!did) {
+      return "You are not logged in. Please run `rocksky login <username>.bsky.social` first.";
+    }
+  }
+
+  const tokenData = await fs.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 stats = await client.stats(did);
+
+    return JSON.stringify(
+      {
+        scrobbles: stats.scrobbles,
+        tracks: stats.tracks,
+        albums: stats.albums,
+        artists: stats.artists,
+        lovedTracks: stats.lovedTracks,
+      },
+      null,
+      2
+    );
+  } catch (err) {
+    return `Failed to fetch stats data. Please check your token and try again, error: ${err.message}`;
+  }
+}

package/src/mcp/tools/tracks.ts

@@ -0,0 +1,15 @@
+import { RockskyClient } from "client";
+
+export async function tracks(did, { skip, limit = 20 }) {
+  const client = new RockskyClient();
+  const tracks = await client.getTracks(did, { skip, limit });
+  let rank = 1;
+  let response = `Top ${limit} tracks:\n`;
+
+  for (const track of tracks) {
+    response += `${rank} ${track.title} - ${track.artist} - ${track.play_count} plays\n`;
+    rank++;
+  }
+
+  return response;
+}

package/src/mcp/tools/whoami.ts

@@ -0,0 +1,27 @@
+import { RockskyClient } from "client";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+
+export async function whoami(): Promise<string> {
+  const tokenPath = path.join(os.homedir(), ".rocksky", "token.json");
+  try {
+    await fs.access(tokenPath);
+  } catch (err) {
+    return "You are not logged in. Please run `rocksky login <username>.bsky.social` first.";
+  }
+
+  const tokenData = await fs.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}).\nView your profile at: https://rocksky.app/profile/${user.handle}`;
+  } catch (err) {
+    return "Failed to fetch user data. Please check your token and try again.";
+  }
+}