@rocksky/cli 0.2.0 → 0.3.0

package/src/cmd/whoami.ts

@@ -1,18 +1,47 @@
 import chalk from "chalk";
 import { RockskyClient } from "client";
 import fs from "fs/promises";
+import { createAgent } from "lib/agent";
+import { env } from "lib/env";
+import { getDidAndHandle } from "lib/getDidAndHandle";
 import os from "os";
 import path from "path";
+import { createUser } from "./sync";
+import { ctx } from "context";
+import schema from "schema";
+import { eq } from "drizzle-orm";
 
 export async function whoami() {
+  if (env.ROCKSKY_IDENTIFIER && env.ROCKSKY_PASSWORD) {
+    const [did, handle] = await getDidAndHandle();
+    const agent = await createAgent(did, handle);
+    let user = await ctx.db
+      .select()
+      .from(schema.users)
+      .where(eq(schema.users.did, did))
+      .execute()
+      .then((rows) => rows[0]);
+
+    if (!user) {
+      user = await createUser(agent, did, handle);
+    }
+
+    console.log(`You are logged in as ${user.handle} (${user.displayName}).`);
+    console.log(
+      `View your profile at: ${chalk.magenta(
+        `https://rocksky.app/profile/${user.handle}`,
+      )}`,
+    );
+    return;
+  }
   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.`
+        "`rocksky login <username>.bsky.social`",
+      )} first.`,
     );
     return;
   }
@@ -22,8 +51,8 @@ export async function whoami() {
   if (!token) {
     console.error(
       `You are not logged in. Please run ${chalk.greenBright(
-        "`rocksky login <username>.bsky.social`"
-      )} first.`
+        "`rocksky login <username>.bsky.social`",
+      )} first.`,
     );
     return;
   }
@@ -34,12 +63,12 @@ export async function whoami() {
     console.log(`You are logged in as ${user.handle} (${user.displayName}).`);
     console.log(
       `View your profile at: ${chalk.magenta(
-        `https://rocksky.app/profile/${user.handle}`
-      )}`
+        `https://rocksky.app/profile/${user.handle}`,
+      )}`,
     );
   } catch (err) {
     console.error(
-      `Failed to fetch user data. Please check your token and try again.`
+      `Failed to fetch user data. Please check your token and try again.`,
     );
   }
 }

package/src/context.ts

@@ -0,0 +1,24 @@
+import drizzle from "./drizzle";
+import sqliteKv from "sqliteKv";
+import { createBidirectionalResolver, createIdResolver } from "lib/idResolver";
+import { createStorage } from "unstorage";
+import envpaths from "env-paths";
+import fs from "node:fs";
+
+fs.mkdirSync(envpaths("rocksky", { suffix: "" }).data, { recursive: true });
+const kvPath = `${envpaths("rocksky", { suffix: "" }).data}/rocksky-kv.sqlite`;
+
+const kv = createStorage({
+  driver: sqliteKv({ location: kvPath, table: "kv" }),
+});
+
+const baseIdResolver = createIdResolver(kv);
+
+export const ctx = {
+  db: drizzle.db,
+  resolver: createBidirectionalResolver(baseIdResolver),
+  baseIdResolver,
+  kv,
+};
+
+export type Context = typeof ctx;

package/src/drizzle.ts

@@ -0,0 +1,53 @@
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import Database from "better-sqlite3";
+import envpaths from "env-paths";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+fs.mkdirSync(envpaths("rocksky", { suffix: "" }).data, { recursive: true });
+const url = `${envpaths("rocksky", { suffix: "" }).data}/rocksky.sqlite`;
+
+const sqlite = new Database(url);
+const db = drizzle(sqlite);
+
+let initialized = false;
+
+/**
+ * Initialize the database and run migrations
+ * This should be called before any database operations
+ */
+export async function initializeDatabase() {
+  if (initialized) {
+    return;
+  }
+
+  try {
+    // In production (built), migrations are in ../drizzle
+    // In development (src), migrations are in ../../drizzle
+    let migrationsFolder = path.join(__dirname, "../drizzle");
+
+    if (!fs.existsSync(migrationsFolder)) {
+      // Try development path
+      migrationsFolder = path.join(__dirname, "../../drizzle");
+    }
+
+    if (fs.existsSync(migrationsFolder)) {
+      migrate(db, { migrationsFolder });
+      initialized = true;
+    } else {
+      // No migrations folder found - this might be the first run
+      // or migrations haven't been generated yet
+      initialized = true;
+    }
+  } catch (error) {
+    console.error("Failed to run migrations:", error);
+    throw error;
+  }
+}
+
+export default { db, initializeDatabase };

package/src/index.ts

@@ -13,46 +13,74 @@ import { stats } from "cmd/stats";
 import { tracks } from "cmd/tracks";
 import { whoami } from "cmd/whoami";
 import { Command } from "commander";
-import version from "../package.json" assert { type: "json" };
+import { version } from "../package.json" assert { type: "json" };
 import { login } from "./cmd/login";
+import { sync } from "cmd/sync";
+import { initializeDatabase } from "./drizzle";
+import { scrobbleApi } from "cmd/scrobble-api";
+
+await initializeDatabase();
 
 const program = new Command();
 
 program
   .name("rocksky")
   .description(
-    `Command-line interface for Rocksky (${chalk.underline(
-      "https://rocksky.app"
-    )}) – scrobble tracks, view stats, and manage your listening history.`
+    `
+    ___           __        __          _______   ____
+   / _ \\___  ____/ /__ ___ / /____ __  / ___/ /  /  _/
+  / , _/ _ \\/ __/  '_/(_-</  '_/ // / / /__/ /___/ /
+ /_/|_|\\___/\\__/_/\\_\\/___/_/\\_\\\\_, /  \\___/____/___/
+                              /___/
+ Command-line interface for Rocksky ${chalk.magentaBright(
+   "https://rocksky.app",
+ )} – scrobble tracks, view stats, and manage your listening history.`,
   )
-  .version(version.version);
+  .version(version);
+
+program.configureHelp({
+  styleTitle: (str) => chalk.bold.cyan(str),
+  styleCommandText: (str) => chalk.yellow(str),
+  styleDescriptionText: (str) => chalk.white(str),
+  styleOptionText: (str) => chalk.green(str),
+  styleArgumentText: (str) => chalk.magenta(str),
+  styleSubcommandText: (str) => chalk.blue(str),
+});
+
+program.addHelpText(
+  "after",
+  `
+${chalk.bold("\nLearn more about Rocksky:")}               https://docs.rocksky.app
+${chalk.bold("Join our Discord community:")}        ${chalk.blueBright("https://discord.gg/EVcBy2fVa3")}
+`,
+);
 
 program
   .command("login")
-  .argument("<handle>", "your BlueSky handle (e.g., <username>.bsky.social)")
-  .description("login with your BlueSky account and get a session token.")
+  .argument("<handle>", "your AT Proto handle (e.g., <username>.bsky.social)")
+  .description("login with your AT Proto account and get a session token")
   .action(login);
 
 program
   .command("whoami")
-  .description("get the current logged-in user.")
+  .description("get the current logged-in user")
   .action(whoami);
 
 program
   .command("nowplaying")
   .argument(
     "[did]",
-    "the DID or handle of the user to get the now playing track for."
+    "the DID or handle of the user to get the now playing track for",
   )
-  .description("get the currently playing track.")
+  .description("get the currently playing track")
   .action(nowplaying);
 
 program
   .command("scrobbles")
   .option("-s, --skip <number>", "number of scrobbles to skip")
   .option("-l, --limit <number>", "number of scrobbles to limit")
-  .argument("[did]", "the DID or handle of the user to get the scrobbles for.")
-  .description("display recently played tracks.")
+  .argument("[did]", "the DID or handle of the user to get the scrobbles for")
+  .description("display recently played tracks")
   .action(scrobbles);
 
 program
@@ -63,37 +91,37 @@ program
   .option("-l, --limit <number>", "number of results to limit")
   .argument(
     "<query>",
-    "the search query, e.g., artist, album, title or account"
+    "the search query, e.g., artist, album, title or account",
   )
-  .description("search for tracks, albums, or accounts.")
+  .description("search for tracks, albums, or accounts")
   .action(search);
 
 program
   .command("stats")
   .option("-l, --limit <number>", "number of results to limit")
-  .argument("[did]", "the DID or handle of the user to get stats for.")
-  .description("get the user's listening stats.")
+  .argument("[did]", "the DID or handle of the user to get stats for")
+  .description("get the user's listening stats")
   .action(stats);
 
 program
   .command("artists")
   .option("-l, --limit <number>", "number of results to limit")
-  .argument("[did]", "the DID or handle of the user to get artists for.")
-  .description("get the user's top artists.")
+  .argument("[did]", "the DID or handle of the user to get artists for")
+  .description("get the user's top artists")
   .action(artists);
 
 program
   .command("albums")
   .option("-l, --limit <number>", "number of results to limit")
-  .argument("[did]", "the DID or handle of the user to get albums for.")
-  .description("get the user's top albums.")
+  .argument("[did]", "the DID or handle of the user to get albums for")
+  .description("get the user's top albums")
   .action(albums);
 
 program
   .command("tracks")
   .option("-l, --limit <number>", "number of results to limit")
-  .argument("[did]", "the DID or handle of the user to get tracks for.")
-  .description("get the user's top tracks.")
+  .argument("[did]", "the DID or handle of the user to get tracks for")
+  .description("get the user's top tracks")
   .action(tracks);
 
 program
@@ -101,21 +129,33 @@ program
   .argument("<track>", "the title of the track")
   .argument("<artist>", "the artist of the track")
   .option("-t, --timestamp <timestamp>", "the timestamp of the scrobble")
-  .description("scrobble a track to your profile.")
+  .option("-d, --dry-run", "simulate the scrobble without actually sending it")
+  .description("scrobble a track to your profile")
   .action(scrobble);
 
 program
   .command("create")
-  .description("create a new API key.")
+  .description("create a new API key")
   .command("apikey")
   .argument("<name>", "the name of the API key")
   .option("-d, --description <description>", "the description of the API key")
-  .description("create a new API key.")
+  .description("create a new API key")
   .action(createApiKey);
 
 program
   .command("mcp")
-  .description("Starts an MCP server to use with Claude or other LLMs.")
+  .description("starts an MCP server to use with Claude or other LLMs")
   .action(mcp);
 
+program
+  .command("sync")
+  .description("sync your local Rocksky data from AT Protocol")
+  .action(sync);
+
+program
+  .command("scrobble-api")
+  .description("start a local listenbrainz/lastfm compatibility server")
+  .option("-p, --port <port>", "the port to listen on", "8778")
+  .action(scrobbleApi);
+
 program.parse(process.argv);

package/src/jetstream.ts

@@ -0,0 +1,285 @@
+export interface JetStreamEvent {
+  did: string;
+  time_us: number;
+  kind: "commit" | "identity" | "account";
+  commit?: {
+    rev: string;
+    operation: "create" | "update" | "delete";
+    collection: string;
+    rkey: string;
+    record?: Record<string, unknown>;
+    cid?: string;
+  };
+  identity?: {
+    did: string;
+    handle?: string;
+    seq?: number;
+    time?: string;
+  };
+  account?: {
+    active: boolean;
+    did: string;
+    seq: number;
+    time: string;
+  };
+}
+
+export interface JetStreamClientOptions {
+  endpoint?: string;
+  wantedCollections?: string[];
+  wantedDids?: string[];
+  maxReconnectAttempts?: number;
+  reconnectDelay?: number;
+  maxReconnectDelay?: number;
+  backoffMultiplier?: number;
+  debug?: boolean;
+}
+
+export type JetStreamEventType =
+  | "open"
+  | "message"
+  | "error"
+  | "close"
+  | "reconnect";
+
+export class JetStreamClient {
+  private ws: WebSocket | null = null;
+  private options: Required<JetStreamClientOptions>;
+  private reconnectAttempts = 0;
+  private reconnectTimer: number | null = null;
+  private isManualClose = false;
+  private eventHandlers: Map<
+    JetStreamEventType,
+    Set<(data?: unknown) => void>
+  > = new Map();
+  private cursor: number | null = null;
+
+  constructor(options: JetStreamClientOptions = {}) {
+    this.options = {
+      endpoint:
+        options.endpoint || "wss://jetstream1.us-east.bsky.network/subscribe",
+      wantedCollections: options.wantedCollections || [],
+      wantedDids: options.wantedDids || [],
+      maxReconnectAttempts: options.maxReconnectAttempts ?? Infinity,
+      reconnectDelay: options.reconnectDelay ?? 1000,
+      maxReconnectDelay: options.maxReconnectDelay ?? 30000,
+      backoffMultiplier: options.backoffMultiplier ?? 1.5,
+      debug: options.debug ?? false,
+    };
+
+    // Initialize event handler sets
+    ["open", "message", "error", "close", "reconnect"].forEach((event) => {
+      this.eventHandlers.set(event as JetStreamEventType, new Set());
+    });
+  }
+
+  /**
+   * Register an event handler
+   */
+  on(event: JetStreamEventType, handler: (data?: unknown) => void): this {
+    this.eventHandlers.get(event)?.add(handler);
+    return this;
+  }
+
+  /**
+   * Remove an event handler
+   */
+  off(event: JetStreamEventType, handler: (data?: unknown) => void): this {
+    this.eventHandlers.get(event)?.delete(handler);
+    return this;
+  }
+
+  /**
+   * Emit an event to all registered handlers
+   */
+  private emit(event: JetStreamEventType, data?: unknown): void {
+    this.eventHandlers.get(event)?.forEach((handler) => {
+      try {
+        handler(data);
+      } catch (error) {
+        this.log("error", `Handler error for ${event}:`, error);
+      }
+    });
+  }
+
+  /**
+   * Build the WebSocket URL with query parameters
+   */
+  private buildUrl(): string {
+    const url = new URL(this.options.endpoint);
+
+    if (this.options.wantedCollections.length > 0) {
+      this.options.wantedCollections.forEach((collection) => {
+        url.searchParams.append("wantedCollections", collection);
+      });
+    }
+
+    if (this.options.wantedDids.length > 0) {
+      this.options.wantedDids.forEach((did) => {
+        url.searchParams.append("wantedDids", did);
+      });
+    }
+
+    if (this.cursor !== null) {
+      url.searchParams.set("cursor", this.cursor.toString());
+    }
+
+    return url.toString();
+  }
+
+  /**
+   * Connect to the JetStream WebSocket
+   */
+  connect(): void {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.log("warn", "Already connected");
+      return;
+    }
+
+    this.isManualClose = false;
+    const url = this.buildUrl();
+    this.log("info", `Connecting to ${url}`);
+
+    try {
+      this.ws = new WebSocket(url);
+
+      this.ws.onopen = () => {
+        this.log("info", "Connected successfully");
+        this.reconnectAttempts = 0;
+        this.emit("open");
+      };
+
+      this.ws.onmessage = (event) => {
+        try {
+          const data = JSON.parse(event.data) as JetStreamEvent;
+
+          // Update cursor for resumption
+          if (data.time_us) {
+            this.cursor = data.time_us;
+          }
+
+          this.emit("message", data);
+        } catch (error) {
+          this.log("error", "Failed to parse message:", error);
+          this.emit("error", { type: "parse_error", error });
+        }
+      };
+
+      this.ws.onerror = (event) => {
+        this.log("error", "WebSocket error:", event);
+        this.emit("error", event);
+      };
+
+      this.ws.onclose = (event) => {
+        this.log("info", `Connection closed: ${event.code} ${event.reason}`);
+        this.emit("close", event);
+
+        if (!this.isManualClose) {
+          this.scheduleReconnect();
+        }
+      };
+    } catch (error) {
+      this.log("error", "Failed to create WebSocket:", error);
+      this.emit("error", { type: "connection_error", error });
+      this.scheduleReconnect();
+    }
+  }
+
+  /**
+   * Schedule a reconnection attempt with exponential backoff
+   */
+  private scheduleReconnect(): void {
+    if (this.reconnectAttempts >= this.options.maxReconnectAttempts) {
+      this.log("error", "Max reconnection attempts reached");
+      return;
+    }
+
+    const delay = Math.min(
+      this.options.reconnectDelay *
+        Math.pow(this.options.backoffMultiplier, this.reconnectAttempts),
+      this.options.maxReconnectDelay,
+    );
+
+    this.reconnectAttempts++;
+    this.log(
+      "info",
+      `Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`,
+    );
+
+    this.reconnectTimer = setTimeout(() => {
+      this.emit("reconnect", { attempt: this.reconnectAttempts });
+      this.connect();
+    }, delay) as unknown as number;
+  }
+
+  /**
+   * Manually disconnect from the WebSocket
+   */
+  disconnect(): void {
+    this.isManualClose = true;
+
+    if (this.reconnectTimer !== null) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+
+    this.log("info", "Disconnected");
+  }
+
+  /**
+   * Update subscription filters (requires reconnection)
+   */
+  updateFilters(options: {
+    wantedCollections?: string[];
+    wantedDids?: string[];
+  }): void {
+    if (options.wantedCollections) {
+      this.options.wantedCollections = options.wantedCollections;
+    }
+    if (options.wantedDids) {
+      this.options.wantedDids = options.wantedDids;
+    }
+
+    // Reconnect with new filters
+    if (this.ws) {
+      this.disconnect();
+      this.connect();
+    }
+  }
+
+  /**
+   * Get current connection state
+   */
+  get readyState(): number {
+    return this.ws?.readyState ?? WebSocket.CLOSED;
+  }
+
+  /**
+   * Check if currently connected
+   */
+  get isConnected(): boolean {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+
+  /**
+   * Get current cursor position
+   */
+  get currentCursor(): number | null {
+    return this.cursor;
+  }
+
+  /**
+   * Logging utility
+   */
+  private log(level: "info" | "warn" | "error", ...args: unknown[]): void {
+    if (this.options.debug || level === "error") {
+      const prefix = `[JetStream ${level.toUpperCase()}]`;
+      console[level](prefix, ...args);
+    }
+  }
+}