@rocksky/cli 0.1.1 → 0.3.0

package/drizzle/meta/_journal.json

@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "6",
+      "when": 1768065262210,
+      "tag": "0000_parallel_paper_doll",
+      "breakpoints": true
+    }
+  ]
+}

package/drizzle.config.ts

@@ -0,0 +1,18 @@
+import { defineConfig } from "drizzle-kit";
+import envpaths from "env-paths";
+import fs from "node:fs";
+import chalk from "chalk";
+
+fs.mkdirSync(envpaths("rocksky", { suffix: "" }).data, { recursive: true });
+const url = `${envpaths("rocksky", { suffix: "" }).data}/rocksky.sqlite`;
+
+console.log(`Database URL: ${chalk.greenBright(url)}`);
+
+export default defineConfig({
+  dialect: "sqlite",
+  schema: "./src/schema",
+  out: "./drizzle",
+  dbCredentials: {
+    url,
+  },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rocksky/cli",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Command-line interface for Rocksky – scrobble tracks, view stats, and manage your listening history",
   "main": "dist/index.js",
   "type": "module",
@@ -8,9 +8,13 @@
     "rocksky": "./dist/index.js"
   },
   "scripts": {
+    "lexgen": "lex gen-server ./src/lexicon ./lexicons/**/* ./lexicons/*",
     "test": "echo \"Error: no test specified\" && exit 1",
     "dev": "tsx ./src/index.ts",
-    "build": "pkgroll && chmod +x ./dist/index.js"
+    "build": "pkgroll && chmod +x ./dist/index.js && cp -r drizzle ./dist",
+    "db:generate": "drizzle-kit generate",
+    "db:migrate": "drizzle-kit migrate",
+    "db:studio": "drizzle-kit studio"
   },
   "keywords": [
     "audioscrobbler",
@@ -22,15 +26,41 @@
   "author": "Tsiry Sandratraina <tsiry.sndr@rocksky.app>",
   "license": "Apache-2.0",
   "dependencies": {
+    "@atproto/api": "^0.13.31",
+    "@atproto/common": "^0.4.6",
+    "@atproto/identity": "^0.4.5",
+    "@atproto/jwk-jose": "0.1.5",
+    "@atproto/lex-cli": "^0.5.6",
+    "@atproto/lexicon": "^0.4.5",
+    "@atproto/sync": "^0.1.11",
+    "@atproto/syntax": "^0.3.1",
+    "@hono/node-server": "^1.13.8",
+    "@logtape/logtape": "^1.3.6",
+    "@modelcontextprotocol/sdk": "^1.10.2",
+    "@paralleldrive/cuid2": "^3.0.6",
+    "@types/better-sqlite3": "^7.6.13",
     "axios": "^1.8.4",
+    "better-sqlite3": "^12.4.1",
     "chalk": "^5.4.1",
     "commander": "^13.1.0",
     "cors": "^2.8.5",
     "dayjs": "^1.11.13",
+    "dotenv": "^16.4.7",
+    "drizzle-kit": "^0.31.1",
+    "drizzle-orm": "^0.45.1",
+    "effect": "^3.19.14",
+    "env-paths": "^3.0.0",
+    "envalid": "^8.0.0",
     "express": "^5.1.0",
+    "hono": "^4.4.7",
+    "kysely": "^0.27.5",
+    "lodash": "^4.17.21",
     "md5": "^2.3.0",
     "open": "^10.1.0",
-    "table": "^6.9.0"
+    "table": "^6.9.0",
+    "unstorage": "^1.14.4",
+    "uuid": "^13.0.0",
+    "zod": "^3.24.3"
   },
   "devDependencies": {
     "@types/express": "^5.0.1",
@@ -44,4 +74,4 @@
       "import": "./dist/index.js"
     }
   }
-}
+}

package/src/client.ts

@@ -35,12 +35,12 @@ export class RockskyClient {
           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}`
+        `Failed to fetch now playing data: ${response.statusText}`,
       );
     }
 
@@ -56,12 +56,12 @@ export class RockskyClient {
           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}`
+        `Failed to fetch now playing data: ${response.statusText}`,
       );
     }
 
@@ -78,11 +78,11 @@ export class RockskyClient {
             Authorization: this.token ? `Bearer ${this.token}` : undefined,
             "Content-Type": "application/json",
           },
-        }
+        },
       );
       if (!response.ok) {
         throw new Error(
-          `Failed to fetch scrobbles data: ${response.statusText}`
+          `Failed to fetch scrobbles data: ${response.statusText}`,
         );
       }
       return response.json();
@@ -96,7 +96,7 @@ export class RockskyClient {
           Authorization: this.token ? `Bearer ${this.token}` : undefined,
           "Content-Type": "application/json",
         },
-      }
+      },
     );
     if (!response.ok) {
       throw new Error(`Failed to fetch scrobbles data: ${response.statusText}`);
@@ -107,14 +107,14 @@ export class RockskyClient {
 
   async search(query: string, { size }) {
     const response = await fetch(
-      `${ROCKSKY_API_URL}/search?q=${query}&size=${size}`,
+      `${ROCKSKY_API_URL}/xrpc/app.rocksky.feed.search?query=${query}&size=${size}`,
       {
         method: "GET",
         headers: {
           Authorization: this.token ? `Bearer ${this.token}` : undefined,
           "Content-Type": "application/json",
         },
-      }
+      },
     );
 
     if (!response.ok) {
@@ -176,7 +176,7 @@ export class RockskyClient {
           Authorization: this.token ? `Bearer ${this.token}` : undefined,
           "Content-Type": "application/json",
         },
-      }
+      },
     );
     if (!response.ok) {
       throw new Error(`Failed to fetch artists data: ${response.statusText}`);
@@ -207,7 +207,7 @@ export class RockskyClient {
           Authorization: this.token ? `Bearer ${this.token}` : undefined,
           "Content-Type": "application/json",
         },
-      }
+      },
     );
     if (!response.ok) {
       throw new Error(`Failed to fetch albums data: ${response.statusText}`);
@@ -238,7 +238,7 @@ export class RockskyClient {
           Authorization: this.token ? `Bearer ${this.token}` : undefined,
           "Content-Type": "application/json",
         },
-      }
+      },
     );
     if (!response.ok) {
       throw new Error(`Failed to fetch tracks data: ${response.statusText}`);
@@ -252,7 +252,7 @@ export class RockskyClient {
       await fs.promises.access(tokenPath);
     } catch (err) {
       console.error(
-        `You are not logged in. Please run the login command first.`
+        `You are not logged in. Please run the login command first.`,
       );
       return;
     }
@@ -279,7 +279,7 @@ export class RockskyClient {
       throw new Error(
         `Failed to scrobble track: ${
           response.statusText
-        } ${await response.text()}`
+        } ${await response.text()}`,
       );
     }
 
@@ -321,4 +321,22 @@ export class RockskyClient {
 
     return response.json();
   }
+
+  async matchSong(title: string, artist: string) {
+    const q = new URLSearchParams({
+      title,
+      artist,
+    });
+    const response = await fetch(
+      `${ROCKSKY_API_URL}/xrpc/app.rocksky.song.matchSong?${q.toString()}`,
+    );
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to match song: ${response.statusText} ${await response.text()}`,
+      );
+    }
+
+    return response.json();
+  }
 }

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/cmd/scrobble-api.ts

@@ -0,0 +1,457 @@
+import { Hono } from "hono";
+import { logger } from "hono/logger";
+import { cors } from "hono/cors";
+import { serve } from "@hono/node-server";
+import { env } from "lib/env";
+import chalk from "chalk";
+import { logger as log } from "logger";
+import { getDidAndHandle } from "lib/getDidAndHandle";
+import { WebScrobbler, Listenbrainz, Lastfm } from "types";
+import { matchTrack } from "lib/matchTrack";
+import _ from "lodash";
+import { publishScrobble } from "scrobble";
+import { validateLastfmSignature } from "lib/lastfm";
+
+export async function scrobbleApi({ port }) {
+  const [, handle] = await getDidAndHandle();
+  const app = new Hono();
+
+  if (
+    !process.env.ROCKSKY_API_KEY ||
+    !process.env.ROCKSKY_SHARED_SECRET ||
+    !process.env.ROCKSKY_SESSION_KEY
+  ) {
+    console.log(`ROCKSKY_API_KEY: ${env.ROCKSKY_API_KEY}`);
+    console.log(`ROCKSKY_SHARED_SECRET: ${env.ROCKSKY_SHARED_SECRET}`);
+    console.log(`ROCKSKY_SESSION_KEY: ${env.ROCKSKY_SESSION_KEY}`);
+  } else {
+    console.log(
+      "ROCKSKY_API_KEY, ROCKSKY_SHARED_SECRET and ROCKSKY_SESSION_KEY are set from environment variables",
+    );
+  }
+
+  if (!process.env.ROCKSKY_WEBSCROBBLER_KEY) {
+    console.log(`ROCKSKY_WEBSCROBBLER_KEY: ${env.ROCKSKY_WEBSCROBBLER_KEY}`);
+  } else {
+    console.log("ROCKSKY_WEBSCROBBLER_KEY is set from environment variables");
+  }
+
+  const BANNER = `
+    ____             __        __
+   / __ \\____  _____/ /_______/ /____  __
+  / /_/ / __ \\/ ___/ //_/ ___/ //_/ / / /
+ / _, _/ /_/ / /__/ ,< (__  ) ,< / /_/ /
+/_/ |_|\\____/\\___/_/|_/____/_/|_|\\__, /
+                                /____/
+  `;
+
+  console.log(chalk.cyanBright(BANNER));
+
+  app.use(logger());
+  app.use(cors());
+
+  app.get("/", (c) =>
+    c.text(
+      `${BANNER}\nWelcome to the lastfm/listenbrainz/webscrobbler compatibility API\n`,
+    ),
+  );
+
+  app.post("/nowplaying", async (c) => {
+    const formData = await c.req.parseBody();
+    const params = Object.fromEntries(
+      Object.entries(formData).map(([k, v]) => [k, String(v)]),
+    );
+
+    if (params.s !== env.ROCKSKY_SESSION_KEY) {
+      return c.text("BADSESSION\n");
+    }
+
+    const {
+      data: nowPlaying,
+      success,
+      error,
+    } = Lastfm.LegacyNowPlayingRequestSchema.safeParse(params);
+
+    if (!success) {
+      return c.text(`FAILED Invalid request: ${error}\n`);
+    }
+
+    log.info`Legacy API - Now playing: ${nowPlaying.t} by ${nowPlaying.a}`;
+
+    return c.text("OK\n");
+  });
+
+  app.post("/submission", async (c) => {
+    const formData = await c.req.parseBody();
+    const params = Object.fromEntries(
+      Object.entries(formData).map(([k, v]) => [k, String(v)]),
+    );
+
+    if (params.s !== env.ROCKSKY_SESSION_KEY) {
+      return c.text("BADSESSION\n");
+    }
+
+    const {
+      data: submission,
+      success,
+      error,
+    } = Lastfm.LegacySubmissionRequestSchema.safeParse(params);
+
+    if (!success) {
+      return c.text(`FAILED Invalid request: ${error}\n`);
+    }
+
+    log.info`Legacy API - Received scrobble: ${submission["t[0]"]} by ${submission["a[0]"]}`;
+
+    // Process scrobble asynchronously
+    (async () => {
+      const track = submission["t[0]"];
+      const artist = submission["a[0]"];
+      const timestamp = parseInt(submission["i[0]"]);
+
+      const match = await matchTrack(track, artist);
+
+      if (!match) {
+        log.warn`No match found for ${track} by ${artist}`;
+        return;
+      }
+
+      await publishScrobble(match, timestamp);
+    })().catch((err) => {
+      log.error`Error processing legacy API scrobble: ${err}`;
+    });
+
+    return c.text("OK\n");
+  });
+
+  app.get("/2.0", async (c) => {
+    const params = Object.fromEntries(
+      Object.entries(c.req.query()).map(([k, v]) => [k, String(v)]),
+    );
+
+    if (params.method === "auth.getSession") {
+      if (params.api_key !== env.ROCKSKY_API_KEY) {
+        return c.json({
+          error: 10,
+          message: "Invalid API key",
+        });
+      }
+
+      if (!validateLastfmSignature(params)) {
+        return c.json({
+          error: 13,
+          message: "Invalid method signature supplied",
+        });
+      }
+
+      return c.json({
+        session: {
+          name: handle,
+          key: env.ROCKSKY_SESSION_KEY,
+          subscriber: 0,
+        },
+      });
+    }
+
+    return c.text(`${BANNER}\nWelcome to the lastfm compatibility API\n`);
+  });
+
+  app.post("/2.0", async (c) => {
+    const contentType = c.req.header("content-type");
+    let params: Record<string, string> = {};
+
+    if (contentType?.includes("application/x-www-form-urlencoded")) {
+      const formData = await c.req.parseBody();
+      params = Object.fromEntries(
+        Object.entries(formData).map(([k, v]) => [k, String(v)]),
+      );
+    } else {
+      params = await c.req.json();
+    }
+
+    log.info`Received Last.fm API request: method=${params.method}`;
+
+    if (params.api_key !== env.ROCKSKY_API_KEY) {
+      return c.json({
+        error: 10,
+        message: "Invalid API key",
+      });
+    }
+
+    if (!validateLastfmSignature(params)) {
+      return c.json({
+        error: 13,
+        message: "Invalid method signature supplied",
+      });
+    }
+
+    if (params.method === "auth.getSession") {
+      return c.json({
+        session: {
+          name: handle,
+          key: env.ROCKSKY_SESSION_KEY,
+          subscriber: 0,
+        },
+      });
+    }
+
+    if (params.method === "track.updateNowPlaying") {
+      // Validate session key
+      if (params.sk !== env.ROCKSKY_SESSION_KEY) {
+        return c.json({
+          error: 9,
+          message: "Invalid session key",
+        });
+      }
+
+      log.info`Now playing: ${params.track} by ${params.artist}`;
+      return c.json({
+        nowplaying: {
+          artist: { "#text": params.artist },
+          track: { "#text": params.track },
+          album: { "#text": params.album || "" },
+          ignoredMessage: { code: "0", "#text": "" },
+        },
+      });
+    }
+
+    if (params.method === "track.scrobble") {
+      // Validate session key
+      if (params.sk !== env.ROCKSKY_SESSION_KEY) {
+        return c.json({
+          error: 9,
+          message: "Invalid session key",
+        });
+      }
+
+      const track = params["track[0]"] || params.track;
+      const artist = params["artist[0]"] || params.artist;
+      const timestamp = params["timestamp[0]"] || params.timestamp;
+
+      log.info`Received Last.fm scrobble: ${track} by ${artist}`;
+
+      // Process scrobble asynchronously
+      (async () => {
+        const match = await matchTrack(track, artist);
+
+        if (!match) {
+          log.warn`No match found for ${track} by ${artist}`;
+          return;
+        }
+
+        const ts = timestamp
+          ? parseInt(timestamp)
+          : Math.floor(Date.now() / 1000);
+        await publishScrobble(match, ts);
+      })().catch((err) => {
+        log.error`Error processing Last.fm scrobble: ${err}`;
+      });
+
+      return c.json({
+        scrobbles: {
+          "@attr": {
+            accepted: 1,
+            ignored: 0,
+          },
+          scrobble: {
+            artist: { "#text": artist },
+            track: { "#text": track },
+            album: { "#text": params["album[0]"] || params.album || "" },
+            timestamp: timestamp || String(Math.floor(Date.now() / 1000)),
+            ignoredMessage: { code: "0", "#text": "" },
+          },
+        },
+      });
+    }
+
+    return c.json({
+      error: 3,
+      message: "Invalid method",
+    });
+  });
+
+  app.post("/1/submit-listens", async (c) => {
+    const authHeader = c.req.header("Authorization");
+
+    if (!authHeader || !authHeader.startsWith("Token ")) {
+      return c.json(
+        {
+          code: 401,
+          error: "Unauthorized",
+        },
+        401,
+      );
+    }
+
+    const token = authHeader.substring(6); // Remove "Token " prefix
+    if (token !== env.ROCKSKY_API_KEY) {
+      return c.json(
+        {
+          code: 401,
+          error: "Invalid token",
+        },
+        401,
+      );
+    }
+
+    const body = await c.req.json();
+    const {
+      data: submitRequest,
+      success,
+      error,
+    } = Listenbrainz.SubmitListensRequestSchema.safeParse(body);
+
+    if (!success) {
+      return c.json(
+        {
+          code: 400,
+          error: `Invalid request body: ${error}`,
+        },
+        400,
+      );
+    }
+
+    log.info`Received ListenBrainz submit-listens request with ${submitRequest.payload.length} payload(s)`;
+
+    if (submitRequest.listen_type !== "single") {
+      log.info`Skipping listen_type: ${submitRequest.listen_type} (only "single" is processed)`;
+      return c.json({
+        status: "ok",
+        payload: {
+          submitted_listens: 0,
+          ignored_listens: 1,
+        },
+        code: 200,
+      });
+    }
+
+    // Process scrobbles asynchronously to avoid timeout
+    (async () => {
+      for (const listen of submitRequest.payload) {
+        const title = listen.track_metadata.track_name;
+        const artist = listen.track_metadata.artist_name;
+
+        log.info`Processing listen: ${title} by ${artist}`;
+
+        const match = await matchTrack(title, artist);
+
+        if (!match) {
+          log.warn`No match found for ${title} by ${artist}`;
+          continue;
+        }
+
+        const timestamp = listen.listened_at || Math.floor(Date.now() / 1000);
+        await publishScrobble(match, timestamp);
+      }
+    })().catch((err) => {
+      log.error`Error processing ListenBrainz scrobbles: ${err}`;
+    });
+
+    return c.json({
+      status: "ok",
+      code: 200,
+    });
+  });
+
+  app.get("/1/validate-token", (c) => {
+    const authHeader = c.req.header("Authorization");
+
+    if (!authHeader || !authHeader.startsWith("Token ")) {
+      return c.json({
+        code: 401,
+        message: "Unauthorized",
+        valid: false,
+      });
+    }
+
+    const token = authHeader.substring(6); // Remove "Token " prefix
+    if (token !== env.ROCKSKY_API_KEY) {
+      return c.json({
+        code: 401,
+        message: "Invalid token",
+        valid: false,
+      });
+    }
+
+    return c.json({
+      code: 200,
+      message: "Token valid.",
+      valid: true,
+      user_name: handle,
+      permissions: ["recording-metadata-write", "recording-metadata-read"],
+    });
+  });
+
+  app.get("/1/search/users", (c) => {
+    return c.json([]);
+  });
+
+  app.get("/1/user/:username/listens", (c) => {
+    return c.json([]);
+  });
+
+  app.get("/1/user/:username/listen-count", (c) => {
+    return c.json({});
+  });
+
+  app.get("/1/user/:username/playing-now", (c) => {
+    return c.json({});
+  });
+
+  app.get("/1/stats/user/:username/artists", (c) => {
+    return c.json({});
+  });
+
+  app.get("/1/stats/user/:username}/releases", (c) => {
+    return c.json({});
+  });
+
+  app.get("/1/stats/user/:username/recordings", (c) => {
+    return c.json([]);
+  });
+
+  app.get("/1/stats/user/:username/release-groups", (c) => {
+    return c.json([]);
+  });
+
+  app.get("/1/stats/user/:username/recordings", (c) => {
+    return c.json({});
+  });
+
+  app.post("/webscrobbler/:uuid", async (c) => {
+    const { uuid } = c.req.param();
+    if (uuid !== env.ROCKSKY_WEBSCROBBLER_KEY) {
+      return c.text("Invalid UUID", 401);
+    }
+
+    const body = await c.req.json();
+    const {
+      data: scrobble,
+      success,
+      error,
+    } = WebScrobbler.ScrobbleRequestSchema.safeParse(body);
+
+    if (!success) {
+      return c.text(`Invalid request body: ${error}`, 400);
+    }
+
+    log.info`Received scrobble request: \n ${scrobble}`;
+
+    const title = scrobble.data?.song?.parsed?.track;
+    const artist = scrobble.data?.song?.parsed?.artist;
+    const match = await matchTrack(title, artist);
+
+    if (!match) {
+      log.warn`No match found for ${title} by ${artist}`;
+      return c.text("No match found", 200);
+    }
+
+    await publishScrobble(match, scrobble.time);
+
+    return c.text("Scrobble received");
+  });
+
+  log.info`lastfm/listenbrainz/webscrobbler scrobble API listening on ${"http://localhost:" + port}`;
+
+  serve({ fetch: app.fetch, port });
+}