@rocksky/cli 0.1.1 → 0.3.0

package/src/lib/agent.ts

@@ -0,0 +1,56 @@
+import { Agent, AtpAgent } from "@atproto/api";
+import { ctx } from "context";
+import { eq } from "drizzle-orm";
+import authSessions from "schema/auth-session";
+import extractPdsFromDid from "./extractPdsFromDid";
+import { env } from "./env";
+import { logger } from "logger";
+
+export async function createAgent(did: string, handle: string): Promise<Agent> {
+  const pds = await extractPdsFromDid(did);
+  const agent = new AtpAgent({
+    service: new URL(pds),
+  });
+
+  try {
+    const [data] = await ctx.db
+      .select()
+      .from(authSessions)
+      .where(eq(authSessions.key, did))
+      .execute();
+
+    if (!data) {
+      throw new Error("No session found");
+    }
+
+    await agent.resumeSession(JSON.parse(data.session));
+    return agent;
+  } catch (e) {
+    logger.error`Resuming session ${did}`;
+    await ctx.db
+      .delete(authSessions)
+      .where(eq(authSessions.key, did))
+      .execute();
+
+    await agent.login({
+      identifier: handle,
+      password: env.ROCKSKY_PASSWORD,
+    });
+
+    await ctx.db
+      .insert(authSessions)
+      .values({
+        key: did,
+        session: JSON.stringify(agent.session),
+      })
+      .onConflictDoUpdate({
+        target: authSessions.key,
+        set: { session: JSON.stringify(agent.session) },
+      })
+      .execute();
+
+    logger.info`Logged in as ${handle}`;
+
+    return agent;
+  }
+}

package/src/lib/cleanUpJetstreamLock.ts

@@ -0,0 +1,66 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { logger } from "logger";
+
+export function cleanUpJetstreamLockOnExit(did: string) {
+  process.on("exit", async () => {
+    try {
+      await fs.promises.unlink(
+        path.join(os.tmpdir(), `rocksky-jetstream-${did}.lock`),
+      );
+      process.exit(0);
+    } catch (error) {
+      logger.error`Error cleaning up Jetstream lock: ${error}`;
+      process.exit(1);
+    }
+  });
+
+  process.on("SIGINT", async () => {
+    try {
+      await fs.promises.unlink(
+        path.join(os.tmpdir(), `rocksky-jetstream-${did}.lock`),
+      );
+      process.exit(0);
+    } catch (error) {
+      logger.error`Error cleaning up Jetstream lock: ${error}`;
+      process.exit(1);
+    }
+  });
+
+  process.on("SIGTERM", async () => {
+    try {
+      await fs.promises.unlink(
+        path.join(os.tmpdir(), `rocksky-jetstream-${did}.lock`),
+      );
+      process.exit(0);
+    } catch (error) {
+      logger.error`Error cleaning up Jetstream lock: ${error}`;
+      process.exit(1);
+    }
+  });
+
+  process.on("uncaughtException", async () => {
+    try {
+      await fs.promises.unlink(
+        path.join(os.tmpdir(), `rocksky-jetstream-${did}.lock`),
+      );
+      process.exit(1);
+    } catch (error) {
+      logger.error`Error cleaning up Jetstream lock: ${error}`;
+      process.exit(1);
+    }
+  });
+
+  process.on("unhandledRejection", async () => {
+    try {
+      await fs.promises.unlink(
+        path.join(os.tmpdir(), `rocksky-jetstream-${did}.lock`),
+      );
+      process.exit(1);
+    } catch (error) {
+      logger.error`Error cleaning up Jetstream lock: ${error}`;
+      process.exit(1);
+    }
+  });
+}

package/src/lib/cleanUpSyncLock.ts

@@ -0,0 +1,56 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { logger } from "logger";
+
+export function cleanUpSyncLockOnExit(did: string) {
+  process.on("exit", async () => {
+    try {
+      await fs.promises.unlink(path.join(os.tmpdir(), `rocksky-${did}.lock`));
+      process.exit(0);
+    } catch (error) {
+      logger.error`Error cleaning up Sync lock: ${error}`;
+      process.exit(1);
+    }
+  });
+
+  process.on("SIGINT", async () => {
+    try {
+      await fs.promises.unlink(path.join(os.tmpdir(), `rocksky-${did}.lock`));
+      process.exit(0);
+    } catch (error) {
+      logger.error`Error cleaning up Sync lock: ${error}`;
+      process.exit(1);
+    }
+  });
+
+  process.on("SIGTERM", async () => {
+    try {
+      await fs.promises.unlink(path.join(os.tmpdir(), `rocksky-${did}.lock`));
+      process.exit(0);
+    } catch (error) {
+      logger.error`Error cleaning up Sync lock: ${error}`;
+      process.exit(1);
+    }
+  });
+
+  process.on("uncaughtException", async () => {
+    try {
+      await fs.promises.unlink(path.join(os.tmpdir(), `rocksky-${did}.lock`));
+      process.exit(1);
+    } catch (error) {
+      logger.error`Error cleaning up Sync lock: ${error}`;
+      process.exit(1);
+    }
+  });
+
+  process.on("unhandledRejection", async () => {
+    try {
+      await fs.promises.unlink(path.join(os.tmpdir(), `rocksky-${did}.lock`));
+      process.exit(1);
+    } catch (error) {
+      logger.error`Error cleaning up Sync lock: ${error}`;
+      process.exit(1);
+    }
+  });
+}

package/src/lib/didUnstorageCache.ts

@@ -0,0 +1,72 @@
+import type { CacheResult, DidCache, DidDocument } from "@atproto/identity";
+import type { Storage } from "unstorage";
+
+const HOUR = 60e3 * 60;
+const DAY = HOUR * 24;
+
+type CacheVal = {
+  doc: DidDocument;
+  updatedAt: number;
+};
+
+/**
+ * An unstorage based DidCache with staleness and max TTL
+ */
+export class StorageCache implements DidCache {
+  public staleTTL: number;
+  public maxTTL: number;
+  public cache: Storage<CacheVal>;
+  private prefix: string;
+  constructor({
+    store,
+    prefix,
+    staleTTL,
+    maxTTL,
+  }: {
+    store: Storage;
+    prefix: string;
+    staleTTL?: number;
+    maxTTL?: number;
+  }) {
+    this.cache = store as Storage<CacheVal>;
+    this.prefix = prefix;
+    this.staleTTL = staleTTL ?? HOUR;
+    this.maxTTL = maxTTL ?? DAY;
+  }
+
+  async cacheDid(did: string, doc: DidDocument): Promise<void> {
+    await this.cache.set(this.prefix + did, { doc, updatedAt: Date.now() });
+  }
+
+  async refreshCache(
+    did: string,
+    getDoc: () => Promise<DidDocument | null>,
+  ): Promise<void> {
+    const doc = await getDoc();
+    if (doc) {
+      await this.cacheDid(did, doc);
+    }
+  }
+
+  async checkCache(did: string): Promise<CacheResult | null> {
+    const val = await this.cache.get<CacheVal>(this.prefix + did);
+    if (!val) return null;
+    const now = Date.now();
+    const expired = now > val.updatedAt + this.maxTTL;
+    const stale = now > val.updatedAt + this.staleTTL;
+    return {
+      ...val,
+      did,
+      stale,
+      expired,
+    };
+  }
+
+  async clearEntry(did: string): Promise<void> {
+    await this.cache.remove(this.prefix + did);
+  }
+
+  async clear(): Promise<void> {
+    await this.cache.clear(this.prefix);
+  }
+}

package/src/lib/env.ts

@@ -0,0 +1,25 @@
+import dotenv from "dotenv";
+import { cleanEnv, str } from "envalid";
+import crypto from "node:crypto";
+import { v4 as uuid } from "uuid";
+
+dotenv.config();
+
+export const env = cleanEnv(process.env, {
+  ROCKSKY_IDENTIFIER: str({ default: "" }),
+  ROCKSKY_HANDLE: str({ default: "" }),
+  ROCKSKY_PASSWORD: str({ default: "" }),
+  JETSTREAM_SERVER: str({
+    default: "wss://jetstream1.us-west.bsky.network/subscribe",
+  }),
+  ROCKSKY_API_KEY: str({ default: crypto.randomBytes(16).toString("hex") }),
+  ROCKSKY_SHARED_SECRET: str({
+    default: crypto.randomBytes(16).toString("hex"),
+  }),
+  ROCKSKY_SESSION_KEY: str({
+    default: crypto.randomBytes(16).toString("hex"),
+  }),
+  ROCKSKY_WEBSCROBBLER_KEY: str({
+    default: uuid(),
+  }),
+});

package/src/lib/extractPdsFromDid.ts

@@ -0,0 +1,33 @@
+export default async function extractPdsFromDid(
+  did: string,
+): Promise<string | null> {
+  let didDocUrl: string;
+
+  if (did.startsWith("did:plc:")) {
+    didDocUrl = `https://plc.directory/${did}`;
+  } else if (did.startsWith("did:web:")) {
+    const domain = did.substring("did:web:".length);
+    didDocUrl = `https://${domain}/.well-known/did.json`;
+  } else {
+    throw new Error("Unsupported DID method");
+  }
+
+  const response = await fetch(didDocUrl);
+  if (!response.ok) throw new Error("Failed to fetch DID doc");
+
+  const doc: {
+    service?: Array<{
+      type: string;
+      id: string;
+      serviceEndpoint: string;
+    }>;
+  } = await response.json();
+
+  // Find the atproto PDS service
+  const pdsService = doc.service?.find(
+    (s: any) =>
+      s.type === "AtprotoPersonalDataServer" && s.id.endsWith("#atproto_pds"),
+  );
+
+  return pdsService?.serviceEndpoint ?? null;
+}

package/src/lib/getDidAndHandle.ts

@@ -0,0 +1,39 @@
+import { isValidHandle } from "@atproto/syntax";
+import { env } from "./env";
+import { logger } from "logger";
+import { ctx } from "context";
+import chalk from "chalk";
+
+export async function getDidAndHandle(): Promise<[string, string]> {
+  let handle = env.ROCKSKY_HANDLE || env.ROCKSKY_IDENTIFIER;
+  let did = env.ROCKSKY_HANDLE || env.ROCKSKY_IDENTIFIER;
+
+  if (!handle) {
+    console.error(
+      `❌ No AT Proto handle or DID provided, please provide one in the environment variables ${chalk.bold("ROCKSKY_HANDLE")} or ${chalk.bold("ROCKSKY_IDENTIFIER")}`,
+    );
+    process.exit(1);
+  }
+
+  if (!env.ROCKSKY_PASSWORD) {
+    console.error(
+      `❌ No app password provided, please provide one in the environment variable ${chalk.bold("ROCKSKY_PASSWORD")}\nYou can create one at ${chalk.blueBright("https://bsky.app/settings/app-passwords")}`,
+    );
+    process.exit(1);
+  }
+
+  if (handle.startsWith("did:plc:") || handle.startsWith("did:web:")) {
+    handle = await ctx.resolver.resolveDidToHandle(handle);
+  }
+
+  if (!isValidHandle(handle)) {
+    logger.error`❌ Invalid handle: ${handle}`;
+    process.exit(1);
+  }
+
+  if (!did.startsWith("did:plc:") && !did.startsWith("did:web:")) {
+    did = await ctx.baseIdResolver.handle.resolve(did);
+  }
+
+  return [did, handle];
+}

package/src/lib/idResolver.ts

@@ -0,0 +1,52 @@
+import { IdResolver } from "@atproto/identity";
+import type { Storage } from "unstorage";
+import { StorageCache } from "./didUnstorageCache";
+
+const HOUR = 60e3 * 60;
+const DAY = HOUR * 24;
+const WEEK = HOUR * 7;
+
+export function createIdResolver(kv: Storage) {
+  return new IdResolver({
+    didCache: new StorageCache({
+      store: kv,
+      prefix: "didCache:",
+      staleTTL: DAY,
+      maxTTL: WEEK,
+    }),
+  });
+}
+
+export interface BidirectionalResolver {
+  resolveDidToHandle(did: string): Promise<string>;
+  resolveDidsToHandles(dids: string[]): Promise<Record<string, string>>;
+}
+
+export function createBidirectionalResolver(resolver: IdResolver) {
+  return {
+    async resolveDidToHandle(did: string): Promise<string> {
+      const didDoc = await resolver.did.resolveAtprotoData(did);
+
+      // asynchronously double check that the handle resolves back
+      resolver.handle.resolve(didDoc.handle).then((resolvedHandle) => {
+        if (resolvedHandle !== did) {
+          resolver.did.ensureResolve(did, true);
+        }
+      });
+      return didDoc?.handle ?? did;
+    },
+
+    async resolveDidsToHandles(
+      dids: string[],
+    ): Promise<Record<string, string>> {
+      const didHandleMap: Record<string, string> = {};
+      const resolves = await Promise.all(
+        dids.map((did) => this.resolveDidToHandle(did).catch((_) => did)),
+      );
+      for (let i = 0; i < dids.length; i++) {
+        didHandleMap[dids[i]] = resolves[i];
+      }
+      return didHandleMap;
+    },
+  };
+}

package/src/lib/lastfm.ts

@@ -0,0 +1,26 @@
+import { env } from "lib/env";
+import crypto from "node:crypto";
+
+export function generateLastfmSignature(
+  params: Record<string, string>,
+): string {
+  const sortedKeys = Object.keys(params).sort();
+  let signatureString = "";
+  for (const key of sortedKeys) {
+    if (key !== "format" && key !== "callback") {
+      signatureString += key + params[key];
+    }
+  }
+  signatureString += env.ROCKSKY_SHARED_SECRET;
+  return crypto.createHash("md5").update(signatureString, "utf8").digest("hex");
+}
+
+export function validateLastfmSignature(
+  params: Record<string, string>,
+): boolean {
+  const providedSignature = params.api_sig;
+  if (!providedSignature) return false;
+
+  const expectedSignature = generateLastfmSignature(params);
+  return providedSignature === expectedSignature;
+}

package/src/lib/matchTrack.ts

@@ -0,0 +1,47 @@
+import { RockskyClient } from "client";
+import { ctx } from "context";
+import { logger } from "logger";
+import { SelectTrack } from "schema/tracks";
+
+export type MusicBrainzArtist = {
+  mbid: string;
+  name: string;
+};
+
+export type MatchTrackResult = SelectTrack & {
+  genres: string[] | null;
+  artistPicture: string | null;
+  releaseDate: string | null;
+  year: number | null;
+  mbArtists: MusicBrainzArtist[] | null;
+};
+
+export async function matchTrack(
+  track: string,
+  artist: string,
+): Promise<MatchTrackResult | null> {
+  let match;
+  const cached = await ctx.kv.getItem(`${track} - ${artist}`);
+  const client = new RockskyClient();
+
+  if (cached) {
+    match = cached;
+    client.matchSong(track, artist).then((newMatch) => {
+      if (newMatch) {
+        ctx.kv.setItem(`${track} - ${artist}`.toLowerCase(), newMatch);
+      }
+    });
+  } else {
+    match = await client.matchSong(track, artist);
+    await ctx.kv.setItem(`${track} - ${artist}`.toLowerCase(), match);
+  }
+
+  if (!match.title || !match.artist) {
+    logger.error`Failed to match track ${track} by ${artist}`;
+    return null;
+  }
+
+  logger.info`💿 Matched track ${match.title} by ${match.artist}`;
+
+  return match;
+}

package/src/logger.ts

@@ -0,0 +1,18 @@
+import { configure, getConsoleSink, getLogger } from "@logtape/logtape";
+
+await configure({
+  sinks: {
+    console: getConsoleSink(),
+    meta: getConsoleSink(),
+  },
+  loggers: [
+    { category: "@rocksky/cli", lowestLevel: "debug", sinks: ["console"] },
+    {
+      category: ["logtape", "meta"],
+      lowestLevel: "warning",
+      sinks: ["meta"],
+    },
+  ],
+});
+
+export const logger = getLogger("@rocksky/cli");