@rocksky/cli 0.1.0

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@rocksky/cli",
+  "version": "0.1.0",
+  "description": "Command-line interface for Rocksky – scrobble tracks, view stats, and manage your listening history",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "rocksky": "./dist/index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "tsx ./src/index.ts",
+    "build": "pkgroll && chmod +x ./dist/index.js"
+  },
+  "keywords": [
+    "audioscrobbler",
+    "last.fm",
+    "atproto",
+    "bluesky",
+    "cli"
+  ],
+  "author": "Tsiry Sandratraina <tsiry.sndr@rocksky.app>",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "axios": "^1.8.4",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "cors": "^2.8.5",
+    "dayjs": "^1.11.13",
+    "express": "^5.1.0",
+    "md5": "^2.3.0",
+    "open": "^10.1.0",
+    "table": "^6.9.0"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.1",
+    "@types/node": "^22.14.1",
+    "pkgroll": "^2.12.1",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.3"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js"
+    }
+  }
+}

package/src/client.ts

@@ -0,0 +1,324 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+export const ROCKSKY_API_URL = "https://api.rocksky.app";
+
+export class RockskyClient {
+  constructor(private readonly token?: string) {
+    this.token = token;
+  }
+
+  async getCurrentUser() {
+    const response = await fetch(`${ROCKSKY_API_URL}/profile`, {
+      method: "GET",
+      headers: {
+        Authorization: this.token ? `Bearer ${this.token}` : undefined,
+        "Content-Type": "application/json",
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch user data: ${response.statusText}`);
+    }
+
+    return response.json();
+  }
+
+  async getSpotifyNowPlaying(did?: string) {
+    const response = await fetch(
+      `${ROCKSKY_API_URL}/spotify/currently-playing` +
+        (did ? `?did=${did}` : ""),
+      {
+        method: "GET",
+        headers: {
+          Authorization: this.token ? `Bearer ${this.token}` : undefined,
+          "Content-Type": "application/json",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch now playing data: ${response.statusText}`
+      );
+    }
+
+    return response.json();
+  }
+
+  async getNowPlaying(did?: string) {
+    const response = await fetch(
+      `${ROCKSKY_API_URL}/now-playing` + (did ? `?did=${did}` : ""),
+      {
+        method: "GET",
+        headers: {
+          Authorization: this.token ? `Bearer ${this.token}` : undefined,
+          "Content-Type": "application/json",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch now playing data: ${response.statusText}`
+      );
+    }
+
+    return response.json();
+  }
+
+  async scrobbles(did?: string, { skip = 0, limit = 20 } = {}) {
+    if (did) {
+      const response = await fetch(
+        `${ROCKSKY_API_URL}/users/${did}/scrobbles?offset=${skip}&size=${limit}`,
+        {
+          method: "GET",
+          headers: {
+            Authorization: this.token ? `Bearer ${this.token}` : undefined,
+            "Content-Type": "application/json",
+          },
+        }
+      );
+      if (!response.ok) {
+        throw new Error(
+          `Failed to fetch scrobbles data: ${response.statusText}`
+        );
+      }
+      return response.json();
+    }
+
+    const response = await fetch(
+      `${ROCKSKY_API_URL}/public/scrobbles?offset=${skip}&size=${limit}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: this.token ? `Bearer ${this.token}` : undefined,
+          "Content-Type": "application/json",
+        },
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to fetch scrobbles data: ${response.statusText}`);
+    }
+
+    return response.json();
+  }
+
+  async search(query: string, { size }) {
+    const response = await fetch(
+      `${ROCKSKY_API_URL}/search?q=${query}&size=${size}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: this.token ? `Bearer ${this.token}` : undefined,
+          "Content-Type": "application/json",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch search data: ${response.statusText}`);
+    }
+
+    return response.json();
+  }
+
+  async stats(did?: string) {
+    if (!did) {
+      const didFile = path.join(os.homedir(), ".rocksky", "did");
+      try {
+        await fs.promises.access(didFile);
+        did = await fs.promises.readFile(didFile, "utf-8");
+      } catch (err) {
+        const user = await this.getCurrentUser();
+        did = user.did;
+        const didPath = path.join(os.homedir(), ".rocksky");
+        fs.promises.mkdir(didPath, { recursive: true });
+        await fs.promises.writeFile(didFile, did);
+      }
+    }
+
+    const response = await fetch(`${ROCKSKY_API_URL}/users/${did}/stats`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch stats data: ${response.statusText}`);
+    }
+
+    return response.json();
+  }
+
+  async getArtists(did?: string, { skip = 0, limit = 20 } = {}) {
+    if (!did) {
+      const didFile = path.join(os.homedir(), ".rocksky", "did");
+      try {
+        await fs.promises.access(didFile);
+        did = await fs.promises.readFile(didFile, "utf-8");
+      } catch (err) {
+        const user = await this.getCurrentUser();
+        did = user.did;
+        const didPath = path.join(os.homedir(), ".rocksky");
+        fs.promises.mkdir(didPath, { recursive: true });
+        await fs.promises.writeFile(didFile, did);
+      }
+    }
+
+    const response = await fetch(
+      `${ROCKSKY_API_URL}/users/${did}/artists?offset=${skip}&size=${limit}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: this.token ? `Bearer ${this.token}` : undefined,
+          "Content-Type": "application/json",
+        },
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to fetch artists data: ${response.statusText}`);
+    }
+    return response.json();
+  }
+
+  async getAlbums(did?: string, { skip = 0, limit = 20 } = {}) {
+    if (!did) {
+      const didFile = path.join(os.homedir(), ".rocksky", "did");
+      try {
+        await fs.promises.access(didFile);
+        did = await fs.promises.readFile(didFile, "utf-8");
+      } catch (err) {
+        const user = await this.getCurrentUser();
+        did = user.did;
+        const didPath = path.join(os.homedir(), ".rocksky");
+        fs.promises.mkdir(didPath, { recursive: true });
+        await fs.promises.writeFile(didFile, did);
+      }
+    }
+
+    const response = await fetch(
+      `${ROCKSKY_API_URL}/users/${did}/albums?offset=${skip}&size=${limit}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: this.token ? `Bearer ${this.token}` : undefined,
+          "Content-Type": "application/json",
+        },
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to fetch albums data: ${response.statusText}`);
+    }
+    return response.json();
+  }
+
+  async getTracks(did?: string, { skip = 0, limit = 20 } = {}) {
+    if (!did) {
+      const didFile = path.join(os.homedir(), ".rocksky", "did");
+      try {
+        await fs.promises.access(didFile);
+        did = await fs.promises.readFile(didFile, "utf-8");
+      } catch (err) {
+        const user = await this.getCurrentUser();
+        did = user.did;
+        const didPath = path.join(os.homedir(), ".rocksky");
+        fs.promises.mkdir(didPath, { recursive: true });
+        await fs.promises.writeFile(didFile, did);
+      }
+    }
+
+    const response = await fetch(
+      `${ROCKSKY_API_URL}/users/${did}/tracks?offset=${skip}&size=${limit}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: this.token ? `Bearer ${this.token}` : undefined,
+          "Content-Type": "application/json",
+        },
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to fetch tracks data: ${response.statusText}`);
+    }
+    return response.json();
+  }
+
+  async scrobble(api_key, api_sig, track, artist, timestamp) {
+    const tokenPath = path.join(os.homedir(), ".rocksky", "token.json");
+    try {
+      await fs.promises.access(tokenPath);
+    } catch (err) {
+      console.error(
+        `You are not logged in. Please run the login command first.`
+      );
+      return;
+    }
+    const tokenData = await fs.promises.readFile(tokenPath, "utf-8");
+    const { token: sk } = JSON.parse(tokenData);
+    const response = await fetch("https://audioscrobbler.rocksky.app/2.0", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+      },
+      body: new URLSearchParams({
+        method: "track.scrobble",
+        "track[0]": track,
+        "artist[0]": artist,
+        "timestamp[0]": timestamp || Math.floor(Date.now() / 1000),
+        api_key,
+        api_sig,
+        sk,
+        format: "json",
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to scrobble track: ${
+          response.statusText
+        } ${await response.text()}`
+      );
+    }
+
+    return response.json();
+  }
+
+  async getApiKeys() {
+    const response = await fetch(`${ROCKSKY_API_URL}/apikeys`, {
+      method: "GET",
+      headers: {
+        Authorization: this.token ? `Bearer ${this.token}` : undefined,
+        "Content-Type": "application/json",
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch API keys: ${response.statusText}`);
+    }
+
+    return response.json();
+  }
+
+  async createApiKey(name: string, description?: string) {
+    const response = await fetch(`${ROCKSKY_API_URL}/apikeys`, {
+      method: "POST",
+      headers: {
+        Authorization: this.token ? `Bearer ${this.token}` : undefined,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        name,
+        description,
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to create API key: ${response.statusText}`);
+    }
+
+    return response.json();
+  }
+}

package/src/cmd/albums.ts

@@ -0,0 +1,16 @@
+import chalk from "chalk";
+import { RockskyClient } from "client";
+
+export async function albums(did, { skip, limit }) {
+  const client = new RockskyClient();
+  const albums = await client.getAlbums(did, { skip, limit });
+  let rank = 1;
+  for (const album of albums) {
+    console.log(
+      `${rank} ${chalk.magenta(album.title)} ${album.artist} ${chalk.yellow(
+        album.play_count + " plays"
+      )}`
+    );
+    rank++;
+  }
+}

package/src/cmd/artists.ts

@@ -0,0 +1,16 @@
+import chalk from "chalk";
+import { RockskyClient } from "client";
+
+export async function artists(did, { skip, limit }) {
+  const client = new RockskyClient();
+  const artists = await client.getArtists(did, { skip, limit });
+  let rank = 1;
+  for (const artist of artists) {
+    console.log(
+      `${rank} ${chalk.magenta(artist.name)} ${chalk.yellow(
+        artist.play_count + " plays"
+      )}`
+    );
+    rank++;
+  }
+}

package/src/cmd/create.ts

@@ -0,0 +1,45 @@
+import chalk from "chalk";
+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) {
+    console.error(
+      `You are not logged in. Please run ${chalk.greenBright(
+        "`rocksky login <username>.bsky.social`"
+      )} first.`
+    );
+    return;
+  }
+
+  const tokenData = await fs.readFile(tokenPath, "utf-8");
+  const { token } = JSON.parse(tokenData);
+  if (!token) {
+    console.error(
+      `You are not logged in. Please run ${chalk.greenBright(
+        "`rocksky login <username>.bsky.social`"
+      )} first.`
+    );
+    return;
+  }
+
+  const client = new RockskyClient(token);
+  const apikey = await client.createApiKey(name, description);
+  if (!apikey) {
+    console.error(`Failed to create API key. Please try again later.`);
+    return;
+  }
+
+  console.log(`API key created successfully!`);
+  console.log(`Name: ${chalk.greenBright(apikey.name)}`);
+  if (apikey.description) {
+    console.log(`Description: ${chalk.greenBright(apikey.description)}`);
+  }
+  console.log(`Key: ${chalk.greenBright(apikey.api_key)}`);
+  console.log(`Secret: ${chalk.greenBright(apikey.shared_secret)}`);
+}

package/src/cmd/login.ts

@@ -0,0 +1,55 @@
+import axios from "axios";
+import chalk from "chalk";
+import cors from "cors";
+import express, { Request, Response } from "express";
+import fs from "fs/promises";
+import open from "open";
+import os from "os";
+import path from "path";
+
+export async function login(handle: string): Promise<void> {
+  const app = express();
+  app.use(cors());
+  app.use(express.json());
+
+  const server = app.listen(6996);
+
+  app.post("/token", async (req: Request, res: Response) => {
+    console.log(chalk.bold(chalk.greenBright("Login successful!\n")));
+    console.log(
+      "You can use this session key (Token) to authenticate with the API."
+    );
+    console.log("Received token (session key):", chalk.green(req.body.token));
+
+    const tokenPath = path.join(os.homedir(), ".rocksky", "token.json");
+    await fs.mkdir(path.dirname(tokenPath), { recursive: true });
+    await fs.writeFile(
+      tokenPath,
+      JSON.stringify({ token: req.body.token }, null, 2)
+    );
+
+    res.json({
+      ok: 1,
+    });
+
+    server.close();
+  });
+
+  const response = await axios.post("https://api.rocksky.app/login", {
+    handle,
+    cli: true,
+  });
+
+  const redirectUrl = response.data;
+
+  if (!redirectUrl.includes("authorize")) {
+    console.error("Failed to login, please check your handle and try again.");
+    server.close();
+    return;
+  }
+
+  console.log("Please visit this URL to authorize the app:");
+  console.log(chalk.cyan(redirectUrl));
+
+  open(redirectUrl);
+}

package/src/cmd/nowplaying.ts

@@ -0,0 +1,61 @@
+import chalk from "chalk";
+import { RockskyClient } from "client";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+
+export async function nowplaying(did?: string) {
+  const tokenPath = path.join(os.homedir(), ".rocksky", "token.json");
+  try {
+    await fs.access(tokenPath);
+  } catch (err) {
+    if (!did) {
+      console.error(
+        `You are not logged in. Please run ${chalk.greenBright(
+          "`rocksky login <username>.bsky.social`"
+        )} first.`
+      );
+      return;
+    }
+  }
+
+  const tokenData = await fs.readFile(tokenPath, "utf-8");
+  const { token } = JSON.parse(tokenData);
+  if (!token && !did) {
+    console.error(
+      `You are not logged in. Please run ${chalk.greenBright(
+        "`rocksky login <username>.bsky.social`"
+      )} first.`
+    );
+    return;
+  }
+
+  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) {
+        console.log("No track is currently playing.");
+        return;
+      }
+      console.log(chalk.magenta(`${nowPlaying.title} - ${nowPlaying.artist}`));
+      console.log(`${nowPlaying.album}`);
+      return;
+    }
+
+    console.log(
+      chalk.magenta(
+        `${nowPlaying.item.name} - ${nowPlaying.item.artists
+          .map((a) => a.name)
+          .join(", ")}`
+      )
+    );
+    console.log(`${nowPlaying.item.album.name}`);
+  } catch (err) {
+    console.log(err);
+    console.error(
+      `Failed to fetch now playing data. Please check your token and try again.`
+    );
+  }
+}

package/src/cmd/scrobble.ts

@@ -0,0 +1,69 @@
+import chalk from "chalk";
+import { RockskyClient } from "client";
+import fs from "fs/promises";
+import md5 from "md5";
+import os from "os";
+import path from "path";
+
+export async function scrobble(track, artist, { timestamp }) {
+  const tokenPath = path.join(os.homedir(), ".rocksky", "token.json");
+  try {
+    await fs.access(tokenPath);
+  } catch (err) {
+    console.error(
+      `You are not logged in. Please run ${chalk.greenBright(
+        "`rocksky login <username>.bsky.social`"
+      )} first.`
+    );
+    return;
+  }
+
+  const tokenData = await fs.readFile(tokenPath, "utf-8");
+  const { token } = JSON.parse(tokenData);
+  if (!token) {
+    console.error(
+      `You are not logged in. Please run ${chalk.greenBright(
+        "`rocksky login <username>.bsky.social`"
+      )} first.`
+    );
+    return;
+  }
+
+  const client = new RockskyClient(token);
+  const apikeys = await client.getApiKeys();
+
+  if (!apikeys || apikeys.length === 0 || !apikeys[0].enabled) {
+    console.error(
+      `You don't have any API keys. Please create one using ${chalk.greenBright(
+        "`rocksky create apikey`"
+      )} command.`
+    );
+    return;
+  }
+
+  const signature = md5(
+    `api_key${
+      apikeys[0].apiKey
+    }artist[0]${artist}methodtrack.scrobblesk${token}timestamp[0]${
+      timestamp || Math.floor(Date.now() / 1000)
+    }track[0]${track}${apikeys[0].sharedSecret}`
+  );
+
+  const response = await client.scrobble(
+    apikeys[0].apiKey,
+    signature,
+    track,
+    artist,
+    timestamp
+  );
+
+  console.log(
+    `Scrobbled ${chalk.greenBright(track)} by ${chalk.greenBright(
+      artist
+    )} at ${chalk.greenBright(
+      new Date(
+        (timestamp || Math.floor(Date.now() / 1000)) * 1000
+      ).toLocaleString()
+    )}`
+  );
+}

package/src/cmd/scrobbles.ts

@@ -0,0 +1,30 @@
+import chalk from "chalk";
+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 }) {
+  const client = new RockskyClient();
+  const scrobbles = await client.scrobbles(did, { skip, limit });
+
+  for (const scrobble of scrobbles) {
+    if (did) {
+      console.log(
+        `${chalk.bold.magenta(scrobble.title)} ${
+          scrobble.artist
+        } ${chalk.yellow(dayjs(scrobble.created_at + "Z").fromNow())}`
+      );
+      continue;
+    }
+    const handle = `@${scrobble.user}`;
+    console.log(
+      `${chalk.italic.magentaBright(
+        handle
+      )} is listening to ${chalk.bold.magenta(scrobble.title)} ${
+        scrobble.artist
+      } ${chalk.yellow(dayjs(scrobble.date).fromNow())}`
+    );
+  }
+}