@rocksky/cli 0.1.1 → 0.3.0

package/src/scrobble.ts

@@ -0,0 +1,410 @@
+import { MatchTrackResult } from "lib/matchTrack";
+import { logger } from "logger";
+import dayjs from "dayjs";
+import { createAgent } from "lib/agent";
+import { getDidAndHandle } from "lib/getDidAndHandle";
+import { ctx } from "context";
+import schema from "schema";
+import { and, eq, gte, lte, or, sql } from "drizzle-orm";
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs";
+import chalk from "chalk";
+import * as Album from "lexicon/types/app/rocksky/album";
+import * as Artist from "lexicon/types/app/rocksky/artist";
+import * as Scrobble from "lexicon/types/app/rocksky/scrobble";
+import * as Song from "lexicon/types/app/rocksky/song";
+import { TID } from "@atproto/common";
+import { Agent } from "@atproto/api";
+import { createUser, subscribeToJetstream, sync } from "cmd/sync";
+import _ from "lodash";
+
+export async function publishScrobble(
+  track: MatchTrackResult,
+  timestamp?: number,
+  dryRun?: boolean,
+) {
+  const [did, handle] = await getDidAndHandle();
+  const agent: Agent = await createAgent(did, handle);
+  const recentScrobble = await getRecentScrobble(did, track, timestamp);
+  const user = await createUser(agent, did, handle);
+  await subscribeToJetstream(user);
+
+  const lockFilePath = path.join(os.tmpdir(), `rocksky-${did}.lock`);
+
+  if (fs.existsSync(lockFilePath)) {
+    logger.error(
+      `${chalk.greenBright(handle)} Scrobble publishing failed: lock file exists, maybe rocksky-cli is still syncing?\nPlease wait for rocksky to finish syncing before publishing scrobbles or delete the lock file manually ${chalk.greenBright(lockFilePath)}`,
+    );
+    return false;
+  }
+
+  if (recentScrobble) {
+    logger.info`${handle} Skipping scrobble for ${track.title} by ${track.artist} at ${timestamp ? dayjs.unix(timestamp).format("YYYY-MM-DD HH:mm:ss") : dayjs().format("YYYY-MM-DD HH:mm:ss")} (already scrobbled)`;
+    return true;
+  }
+
+  const totalScrobbles = await countScrobbles(did);
+  if (totalScrobbles === 0) {
+    logger.warn`${handle} No scrobbles found for this user. Are you sure you have successfully synced your scrobbles locally?\nIf not, please run ${"rocksky sync"} to sync your scrobbles before publishing scrobbles.`;
+  }
+
+  logger.info`${handle} Publishing scrobble for ${track.title} by ${track.artist} at ${timestamp ? dayjs.unix(timestamp).format("YYYY-MM-DD HH:mm:ss") : dayjs().format("YYYY-MM-DD HH:mm:ss")}`;
+
+  if (await shouldSync(agent)) {
+    logger.info`${handle} Syncing scrobbles before publishing`;
+    await sync();
+  } else {
+    logger.info`${handle} Local scrobbles are up-to-date, skipping sync`;
+  }
+
+  if (dryRun) {
+    logger.info`${handle} Dry run: Skipping publishing scrobble for ${track.title} by ${track.artist} at ${timestamp ? dayjs.unix(timestamp).format("YYYY-MM-DD HH:mm:ss") : dayjs().format("YYYY-MM-DD HH:mm:ss")}`;
+    return true;
+  }
+
+  const existingTrack = await ctx.db
+    .select()
+    .from(schema.tracks)
+    .where(
+      or(
+        and(
+          sql`LOWER(${schema.tracks.title}) = LOWER(${track.title})`,
+          sql`LOWER(${schema.tracks.artist}) = LOWER(${track.artist})`,
+        ),
+        and(
+          sql`LOWER(${schema.tracks.title}) = LOWER(${track.title})`,
+          sql`LOWER(${schema.tracks.albumArtist}) = LOWER(${track.artist})`,
+        ),
+        and(
+          sql`LOWER(${schema.tracks.title}) = LOWER(${track.title})`,
+          sql`LOWER(${schema.tracks.albumArtist}) = LOWER(${track.albumArtist})`,
+        ),
+      ),
+    )
+    .limit(1)
+    .execute()
+    .then((rows) => rows[0]);
+
+  if (!existingTrack) {
+    await putSongRecord(agent, track);
+  }
+
+  const existingArtist = await ctx.db
+    .select()
+    .from(schema.artists)
+    .where(
+      or(
+        sql`LOWER(${schema.artists.name}) = LOWER(${track.artist})`,
+        sql`LOWER(${schema.artists.name}) = LOWER(${track.albumArtist})`,
+      ),
+    )
+    .limit(1)
+    .execute()
+    .then((rows) => rows[0]);
+
+  if (!existingArtist) {
+    await putArtistRecord(agent, track);
+  }
+
+  const existingAlbum = await ctx.db
+    .select()
+    .from(schema.albums)
+    .where(
+      and(
+        sql`LOWER(${schema.albums.title}) = LOWER(${track.album})`,
+        sql`LOWER(${schema.albums.artist}) = LOWER(${track.albumArtist})`,
+      ),
+    )
+    .limit(1)
+    .execute()
+    .then((rows) => rows[0]);
+
+  if (!existingAlbum) {
+    await putAlbumRecord(agent, track);
+  }
+
+  const scrobbleUri = await putScrobbleRecord(agent, track, timestamp);
+
+  // wait for the scrobble to be published
+  if (scrobbleUri) {
+    const MAX_ATTEMPTS = 40;
+    let attempts = 0;
+    do {
+      const count = await ctx.db
+        .select({
+          count: sql`COUNT(*)`,
+        })
+        .from(schema.scrobbles)
+        .where(eq(schema.scrobbles.uri, scrobbleUri))
+        .execute()
+        .then((rows) => _.get(rows, "[0].count", 0) as number);
+
+      if (count > 0 || attempts >= MAX_ATTEMPTS) {
+        if (attempts == MAX_ATTEMPTS) {
+          logger.error`Failed to detect published scrobble after ${MAX_ATTEMPTS} attempts`;
+        }
+        break;
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, 600));
+      attempts += 1;
+    } while (true);
+  }
+
+  return true;
+}
+
+async function getRecentScrobble(
+  did: string,
+  track: MatchTrackResult,
+  timestamp?: number,
+) {
+  const scrobbleTime = dayjs.unix(timestamp || dayjs().unix());
+  return ctx.db
+    .select({
+      scrobble: schema.scrobbles,
+      user: schema.users,
+      track: schema.tracks,
+    })
+    .from(schema.scrobbles)
+    .innerJoin(schema.users, eq(schema.scrobbles.userId, schema.users.id))
+    .innerJoin(schema.tracks, eq(schema.scrobbles.trackId, schema.tracks.id))
+    .where(
+      and(
+        eq(schema.users.did, did),
+        sql`LOWER(${schema.tracks.title}) = LOWER(${track.title})`,
+        sql`LOWER(${schema.tracks.artist}) = LOWER(${track.artist})`,
+        gte(
+          schema.scrobbles.timestamp,
+          scrobbleTime.subtract(60, "seconds").toDate(),
+        ),
+        lte(
+          schema.scrobbles.timestamp,
+          scrobbleTime.add(60, "seconds").toDate(),
+        ),
+      ),
+    )
+    .limit(1)
+    .then((rows) => rows[0]);
+}
+
+async function countScrobbles(did: string): Promise<number> {
+  return ctx.db
+    .select({ count: sql<number>`count(*)` })
+    .from(schema.scrobbles)
+    .innerJoin(schema.users, eq(schema.scrobbles.userId, schema.users.id))
+    .where(eq(schema.users.did, did))
+    .then((rows) => rows[0].count);
+}
+
+async function putSongRecord(agent: Agent, track: MatchTrackResult) {
+  const rkey = TID.nextStr();
+
+  const record: Song.Record = {
+    $type: "app.rocksky.song",
+    title: track.title,
+    artist: track.artist,
+    artists: track.mbArtists === null ? undefined : track.mbArtists,
+    album: track.album,
+    albumArtist: track.albumArtist,
+    duration: track.duration,
+    releaseDate: track.releaseDate
+      ? new Date(track.releaseDate).toISOString()
+      : undefined,
+    year: track.year === null ? undefined : track.year,
+    albumArtUrl: track.albumArt,
+    composer: track.composer ? track.composer : undefined,
+    lyrics: track.lyrics ? track.lyrics : undefined,
+    trackNumber: track.trackNumber,
+    discNumber: track.discNumber === 0 ? 1 : track.discNumber,
+    copyrightMessage: track.copyrightMessage
+      ? track.copyrightMessage
+      : undefined,
+    createdAt: new Date().toISOString(),
+    spotifyLink: track.spotifyLink ? track.spotifyLink : undefined,
+    tags: track.genres || [],
+    mbid: track.mbId,
+  };
+
+  if (!Song.validateRecord(record).success) {
+    logger.info`${Song.validateRecord(record)}`;
+    logger.info`${record}`;
+    throw new Error("Invalid Song record");
+  }
+
+  try {
+    const res = await agent.com.atproto.repo.putRecord({
+      repo: agent.assertDid,
+      collection: "app.rocksky.song",
+      rkey,
+      record,
+      validate: false,
+    });
+    const uri = res.data.uri;
+    logger.info`Song record created at ${uri}`;
+    return uri;
+  } catch (e) {
+    logger.error`Error creating song record: ${e}`;
+    return null;
+  }
+}
+
+async function putArtistRecord(agent: Agent, track: MatchTrackResult) {
+  const rkey = TID.nextStr();
+  const record: Artist.Record = {
+    $type: "app.rocksky.artist",
+    name: track.albumArtist,
+    createdAt: new Date().toISOString(),
+    pictureUrl: track.artistPicture || undefined,
+    tags: track.genres || [],
+  };
+
+  if (!Artist.validateRecord(record).success) {
+    logger.info`${Artist.validateRecord(record)}`;
+    logger.info`${record}`;
+    throw new Error("Invalid Artist record");
+  }
+
+  try {
+    const res = await agent.com.atproto.repo.putRecord({
+      repo: agent.assertDid,
+      collection: "app.rocksky.artist",
+      rkey,
+      record,
+      validate: false,
+    });
+    const uri = res.data.uri;
+    logger.info`Artist record created at ${uri}`;
+    return uri;
+  } catch (e) {
+    logger.error`Error creating artist record: ${e}`;
+    return null;
+  }
+}
+
+async function putAlbumRecord(agent: Agent, track: MatchTrackResult) {
+  const rkey = TID.nextStr();
+
+  const record = {
+    $type: "app.rocksky.album",
+    title: track.album,
+    artist: track.albumArtist,
+    year: track.year === null ? undefined : track.year,
+    releaseDate: track.releaseDate
+      ? new Date(track.releaseDate).toISOString()
+      : undefined,
+    createdAt: new Date().toISOString(),
+    albumArtUrl: track.albumArt,
+  };
+
+  if (!Album.validateRecord(record).success) {
+    logger.info`${Album.validateRecord(record)}`;
+    logger.info`${record}`;
+    throw new Error("Invalid Album record");
+  }
+
+  try {
+    const res = await agent.com.atproto.repo.putRecord({
+      repo: agent.assertDid,
+      collection: "app.rocksky.album",
+      rkey,
+      record,
+      validate: false,
+    });
+    const uri = res.data.uri;
+    logger.info`Album record created at ${uri}`;
+    return uri;
+  } catch (e) {
+    logger.error`Error creating album record: ${e}`;
+    return null;
+  }
+}
+
+async function putScrobbleRecord(
+  agent: Agent,
+  track: MatchTrackResult,
+  timestamp?: number,
+) {
+  const rkey = TID.nextStr();
+
+  const record: Scrobble.Record = {
+    $type: "app.rocksky.scrobble",
+    title: track.title,
+    albumArtist: track.albumArtist,
+    albumArtUrl: track.albumArt,
+    artist: track.artist,
+    artists: track.mbArtists === null ? undefined : track.mbArtists,
+    album: track.album,
+    duration: track.duration,
+    trackNumber: track.trackNumber,
+    discNumber: track.discNumber === 0 ? 1 : track.discNumber,
+    releaseDate: track.releaseDate
+      ? new Date(track.releaseDate).toISOString()
+      : undefined,
+    year: track.year === null ? undefined : track.year,
+    composer: track.composer ? track.composer : undefined,
+    lyrics: track.lyrics ? track.lyrics : undefined,
+    copyrightMessage: track.copyrightMessage
+      ? track.copyrightMessage
+      : undefined,
+    createdAt: timestamp
+      ? dayjs.unix(timestamp).toISOString()
+      : new Date().toISOString(),
+    spotifyLink: track.spotifyLink ? track.spotifyLink : undefined,
+    tags: track.genres || [],
+    mbid: track.mbId,
+  };
+
+  if (!Scrobble.validateRecord(record).success) {
+    logger.info`${Scrobble.validateRecord(record)}`;
+    logger.info`${record}`;
+    throw new Error("Invalid Scrobble record");
+  }
+
+  try {
+    const res = await agent.com.atproto.repo.putRecord({
+      repo: agent.assertDid,
+      collection: "app.rocksky.scrobble",
+      rkey,
+      record,
+      validate: false,
+    });
+    const uri = res.data.uri;
+    logger.info`Scrobble record created at ${uri}`;
+    return uri;
+  } catch (e) {
+    logger.error`Error creating scrobble record: ${e}`;
+    return null;
+  }
+}
+
+async function shouldSync(agent: Agent): Promise<boolean> {
+  const res = await agent.com.atproto.repo.listRecords({
+    repo: agent.assertDid,
+    collection: "app.rocksky.scrobble",
+    limit: 1,
+  });
+
+  const records = res.data.records as Array<{
+    uri: string;
+    cid: string;
+    value: Scrobble.Record;
+  }>;
+
+  if (!records.length) {
+    logger.info`No scrobble records found`;
+    return true;
+  }
+
+  const { count } = await ctx.db
+    .select({
+      count: sql<number>`count(*)`,
+    })
+    .from(schema.scrobbles)
+    .where(eq(schema.scrobbles.cid, records[0].cid))
+    .execute()
+    .then((result) => result[0]);
+
+  return count === 0;
+}

package/src/sqliteKv.ts

@@ -0,0 +1,173 @@
+import Database from "better-sqlite3";
+import { Kysely, SqliteDialect } from "kysely";
+import { defineDriver } from "unstorage";
+
+interface TableSchema {
+  [k: string]: {
+    id: string;
+    value: string;
+    created_at: string;
+    updated_at: string;
+  };
+}
+
+export type KvDb = Kysely<TableSchema>;
+
+const DRIVER_NAME = "sqlite";
+
+export default defineDriver<
+  {
+    location?: string;
+    table: string;
+    getDb?: () => KvDb;
+  },
+  KvDb
+>(
+  ({
+    location,
+    table = "kv",
+    getDb = (): KvDb => {
+      let _db: KvDb | null = null;
+
+      return (() => {
+        if (_db) {
+          return _db;
+        }
+
+        if (!location) {
+          throw new Error("SQLite location is required");
+        }
+
+        const sqlite = new Database(location, { fileMustExist: false });
+
+        // Enable WAL mode
+        sqlite.pragma("journal_mode = WAL");
+
+        _db = new Kysely<TableSchema>({
+          dialect: new SqliteDialect({
+            database: sqlite,
+          }),
+        });
+
+        // Create table if not exists
+        _db.schema
+          .createTable(table)
+          .ifNotExists()
+          .addColumn("id", "text", (col) => col.primaryKey())
+          .addColumn("value", "text", (col) => col.notNull())
+          .addColumn("created_at", "text", (col) => col.notNull())
+          .addColumn("updated_at", "text", (col) => col.notNull())
+          .execute();
+
+        return _db;
+      })();
+    },
+  }) => {
+    return {
+      name: DRIVER_NAME,
+      options: { location, table },
+      getInstance: getDb,
+
+      async hasItem(key) {
+        const result = await getDb()
+          .selectFrom(table)
+          .select(["id"])
+          .where("id", "=", key)
+          .executeTakeFirst();
+        return !!result;
+      },
+
+      async getItem(key) {
+        const result = await getDb()
+          .selectFrom(table)
+          .select(["value"])
+          .where("id", "=", key)
+          .executeTakeFirst();
+        return result?.value ?? null;
+      },
+
+      async setItem(key: string, value: string) {
+        const now = new Date().toISOString();
+        await getDb()
+          .insertInto(table)
+          .values({
+            id: key,
+            value,
+            created_at: now,
+            updated_at: now,
+          })
+          .onConflict((oc) =>
+            oc.column("id").doUpdateSet({
+              value,
+              updated_at: now,
+            }),
+          )
+          .execute();
+      },
+
+      async setItems(items) {
+        const now = new Date().toISOString();
+
+        await getDb()
+          .transaction()
+          .execute(async (trx) => {
+            await Promise.all(
+              items.map(({ key, value }) => {
+                return trx
+                  .insertInto(table)
+                  .values({
+                    id: key,
+                    value,
+                    created_at: now,
+                    updated_at: now,
+                  })
+                  .onConflict((oc) =>
+                    oc.column("id").doUpdateSet({
+                      value,
+                      updated_at: now,
+                    }),
+                  )
+                  .execute();
+              }),
+            );
+          });
+      },
+
+      async removeItem(key: string) {
+        await getDb().deleteFrom(table).where("id", "=", key).execute();
+      },
+
+      async getMeta(key: string) {
+        const result = await getDb()
+          .selectFrom(table)
+          .select(["created_at", "updated_at"])
+          .where("id", "=", key)
+          .executeTakeFirst();
+        if (!result) {
+          return null;
+        }
+        return {
+          birthtime: new Date(result.created_at),
+          mtime: new Date(result.updated_at),
+        };
+      },
+
+      async getKeys(base = "") {
+        const results = await getDb()
+          .selectFrom(table)
+          .select(["id"])
+          .where("id", "like", `${base}%`)
+          .execute();
+        return results.map((r) => r.id);
+      },
+
+      async clear() {
+        await getDb().deleteFrom(table).execute();
+      },
+
+      async dispose() {
+        await getDb().destroy();
+      },
+    };
+  },
+);