@rocksky/sdk 0.8.1 → 0.10.0

package/dist/remote-player.d.ts

@@ -0,0 +1,124 @@
+/**
+ * RemotePlayer — build a Rocksky-controllable player in a few lines.
+ *
+ * It speaks the remote-control WebSocket protocol (see remote-ws/PROTOCOL.md):
+ * it registers as a device, advertises what you're playing (now-playing, status,
+ * queue), and invokes your handlers when a miniplayer sends a command
+ * (play/pause/next/previous/seek/enqueue/queue actions). Heartbeat, reconnect,
+ * and the device-id handshake are handled for you.
+ *
+ * ```ts
+ * const player = new RemotePlayer({ token, name: "My Player" });
+ * player.on("play", () => engine.play());
+ * player.on("pause", () => engine.pause());
+ * player.on("next", () => engine.next());
+ * player.on("seek", (ms) => engine.seek(ms));
+ * player.connect();
+ * // …then, as your engine plays:
+ * player.setNowPlaying({ title, artist, album, albumArt, durationMs, elapsedMs, isPlaying: true });
+ * player.setStatus("playing");
+ * player.setQueue(items, index);
+ * ```
+ */
+/** Default remote-control WebSocket endpoint. */
+export declare const DEFAULT_REMOTE_WS = "wss://api.rocksky.app/ws";
+/** Now-playing state you advertise. */
+export interface RemoteNowPlaying {
+    title: string;
+    artist: string;
+    album?: string;
+    albumArtist?: string;
+    albumArt?: string;
+    /** Total track length, ms. */
+    durationMs?: number;
+    /** Current position, ms. */
+    elapsedMs?: number;
+    isPlaying?: boolean;
+}
+/** One queue entry. `uploadId` (Rocksky uploads) or `trackId` (Navidrome id). */
+export interface RemoteQueueItem {
+    uploadId?: string;
+    trackId?: string;
+    title: string;
+    artist: string;
+    album?: string;
+    albumArtist?: string;
+    albumArt?: string;
+    durationMs?: number;
+    songUri?: string;
+    albumUri?: string;
+    trackNumber?: number;
+}
+/** Payload of an `enqueue` command from a controller (an album or a track). */
+export interface EnqueueCommand {
+    tracks: RemoteQueueItem[];
+    mode: "now" | "next" | "last";
+    shuffle: boolean;
+    startIndex: number;
+}
+/** Handlers for commands a controller sends to this player. */
+export interface RemotePlayerHandlers {
+    play(): void;
+    pause(): void;
+    next(): void;
+    previous(): void;
+    seek(positionMs: number): void;
+    enqueue(cmd: EnqueueCommand): void;
+    queueJump(index: number): void;
+    queueRemove(index: number): void;
+}
+type Handler<K extends keyof RemotePlayerHandlers> = RemotePlayerHandlers[K];
+export interface RemotePlayerOptions {
+    /** Rocksky access token, or a getter (read fresh on each (re)connect/send). */
+    token: string | (() => string | undefined);
+    /** Display name shown in the miniplayer device picker. */
+    name: string;
+    /** WebSocket endpoint. Defaults to {@link DEFAULT_REMOTE_WS}. */
+    url?: string;
+    /** Heartbeat interval, ms (default 10000). */
+    heartbeatMs?: number;
+    /** Reconnect delay after a drop, ms (default 3000). */
+    reconnectMs?: number;
+    /** Optional debug logger. */
+    debug?: (...args: unknown[]) => void;
+}
+export declare class RemotePlayer {
+    private readonly opts;
+    private ws;
+    private deviceId;
+    private stopped;
+    private heartbeat?;
+    private reconnectTimer?;
+    private readonly url;
+    private readonly heartbeatMs;
+    private readonly reconnectMs;
+    private readonly getToken;
+    private readonly debug;
+    private handlers;
+    private lastTrack;
+    private lastStatus;
+    private lastQueue;
+    constructor(opts: RemotePlayerOptions);
+    /** Register a handler for a command. Returns `this` for chaining. */
+    on<K extends keyof RemotePlayerHandlers>(event: K, handler: Handler<K>): this;
+    /** The server-assigned device id (empty until registered). */
+    get id(): string;
+    /** Connect, register, and start the heartbeat + auto-reconnect loop. */
+    connect(): void;
+    /** Tear the connection down and stop reconnecting. */
+    disconnect(): void;
+    /** Advertise the current track. Call whenever it changes, and periodically
+     *  (~every 1–4s) with fresh `elapsedMs` so controllers show smooth progress. */
+    setNowPlaying(track: RemoteNowPlaying): void;
+    /** Advertise transport state. */
+    setStatus(status: "playing" | "paused" | "stopped"): void;
+    /** Advertise the playback queue + current index. */
+    setQueue(items: RemoteQueueItem[], index: number): void;
+    private send;
+    private open;
+    private handle;
+    private dispatch;
+    private resync;
+}
+export {};
+//# sourceMappingURL=remote-player.d.ts.map

package/dist/remote-player.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-player.d.ts","sourceRoot":"","sources":["../src/remote-player.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rocksky/sdk",
-  "version": "0.8.1",
+  "version": "0.10.0",
   "description": "TypeScript SDK for Rocksky — built on atcute: AppView reads, AT Protocol PDS writes (scrobble, like, follow, shout), a local dedup index, and Jetstream real-time sync.",
   "license": "MIT",
   "repository": {

package/src/index.ts

@@ -21,6 +21,22 @@ export {
 } from "./agent.js";
 export { RockskyIndex, totalIndexed, type IndexStats } from "./dedup.js";
 export { runJetstream, DEFAULT_JETSTREAM_SERVERS, type JetstreamOptions } from "./jetstream.js";
+export {
+  RemotePlayer,
+  DEFAULT_REMOTE_WS,
+  type RemotePlayerOptions,
+  type RemotePlayerHandlers,
+  type RemoteNowPlaying,
+  type RemoteQueueItem,
+  type EnqueueCommand,
+} from "./remote-player.js";
+export {
+  RemoteController,
+  type RemoteControllerOptions,
+  type RemoteControllerEvents,
+  type RemoteDevice,
+  type RemoteStatus,
+} from "./remote-controller.js";
 export { songHash, albumHash, artistHash } from "./hash.js";
 export { RockskyError } from "./errors.js";
 export type * from "./generated/types.js";

package/src/remote-controller.ts

@@ -0,0 +1,362 @@
+/**
+ * RemoteController — build a Rocksky remote UI in a few lines.
+ *
+ * The other half of the remote-control WebSocket protocol (see
+ * remote-ws/PROTOCOL.md): where {@link RemotePlayer} is a controllable player, a
+ * controller lists the user's players, observes what each is playing
+ * (now-playing / status / queue), picks the primary device, and sends commands
+ * (play/pause/next/previous/seek/queue actions/enqueue). Heartbeat, reconnect,
+ * and the register handshake are handled for you.
+ *
+ * ```ts
+ * const controller = new RemoteController({ token, name: "My Controller" });
+ * controller.on("devices", (d) => render(d.devices));
+ * controller.on("nowPlaying", (e) => showTrack(e.deviceId, e.track));
+ * controller.connect();
+ * // …then drive a device:
+ * controller.setPrimary(deviceId);
+ * controller.pause(deviceId);
+ * controller.seek(deviceId, 42000);
+ * ```
+ */
+
+import { DEFAULT_REMOTE_WS, type RemoteNowPlaying, type RemoteQueueItem } from "./remote-player.js";
+
+export { DEFAULT_REMOTE_WS, type RemoteNowPlaying, type RemoteQueueItem };
+
+/** A player device visible to the controller. */
+export interface RemoteDevice {
+  deviceId: string;
+  name: string;
+  nowPlaying?: RemoteNowPlaying;
+  queueIndex: number;
+  queue: RemoteQueueItem[];
+}
+
+/** Transport state advertised by a device. */
+export type RemoteStatus = "playing" | "paused" | "stopped";
+
+/** Events the controller emits (from the server). */
+export interface RemoteControllerEvents {
+  /** The full device snapshot (on connect + reconnect). */
+  devices(payload: { primaryDevice: string | null; devices: RemoteDevice[] }): void;
+  deviceRegistered(payload: { deviceId: string; name: string }): void;
+  deviceUnregistered(payload: { deviceId: string }): void;
+  primaryChanged(payload: { deviceId: string }): void;
+  nowPlaying(payload: { deviceId: string; deviceName: string; track: RemoteNowPlaying }): void;
+  status(payload: { deviceId: string; deviceName: string; status: RemoteStatus }): void;
+  queue(payload: {
+    deviceId: string;
+    deviceName: string;
+    index: number;
+    queue: RemoteQueueItem[];
+  }): void;
+}
+
+type EventName = keyof RemoteControllerEvents;
+type EventHandler<K extends EventName> = RemoteControllerEvents[K];
+
+export interface RemoteControllerOptions {
+  /** Rocksky access token, or a getter (read fresh on each (re)connect/send). */
+  token: string | (() => string | undefined);
+  /** Registration label (controllers are hidden from device lists). */
+  name: string;
+  /** WebSocket endpoint. Defaults to {@link DEFAULT_REMOTE_WS}. */
+  url?: string;
+  /** Heartbeat interval, ms (default 10000). */
+  heartbeatMs?: number;
+  /** Reconnect delay after a drop, ms (default 3000). */
+  reconnectMs?: number;
+  /** Optional debug logger. */
+  debug?: (...args: unknown[]) => void;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Json = any;
+
+export class RemoteController {
+  private ws: WebSocket | null = null;
+  private stopped = false;
+  private heartbeat?: ReturnType<typeof setInterval>;
+  private reconnectTimer?: ReturnType<typeof setTimeout>;
+
+  private readonly url: string;
+  private readonly heartbeatMs: number;
+  private readonly reconnectMs: number;
+  private readonly getToken: () => string | undefined;
+  private readonly debug: (...args: unknown[]) => void;
+
+  private handlers: { [K in EventName]?: EventHandler<K> } = {};
+
+  constructor(private readonly opts: RemoteControllerOptions) {
+    this.url = opts.url ?? DEFAULT_REMOTE_WS;
+    this.heartbeatMs = opts.heartbeatMs ?? 10_000;
+    this.reconnectMs = opts.reconnectMs ?? 3_000;
+    this.getToken =
+      typeof opts.token === "function" ? opts.token : () => opts.token as string;
+    this.debug = opts.debug ?? (() => {});
+  }
+
+  /** Subscribe to a server event. Returns `this` for chaining. */
+  on<K extends EventName>(event: K, handler: EventHandler<K>): this {
+    this.handlers[event] = handler;
+    return this;
+  }
+
+  /** Connect, register, and start the heartbeat + auto-reconnect loop. */
+  connect(): void {
+    this.stopped = false;
+    this.open();
+  }
+
+  /** Tear the connection down and stop reconnecting. */
+  disconnect(): void {
+    this.stopped = true;
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    if (this.heartbeat) clearInterval(this.heartbeat);
+    try {
+      this.ws?.close();
+    } catch {
+      /* ignore */
+    }
+    this.ws = null;
+  }
+
+  // ── Controls ──────────────────────────────────────────────────────────────
+
+  /** Choose the primary (scrobble/profile) device. */
+  setPrimary(deviceId: string): void {
+    this.send({ type: "set_primary", device_id: deviceId, token: this.getToken() });
+  }
+
+  /** `play`. `target` is a device id, or omit to broadcast to all devices. */
+  play(target?: string): void {
+    this.command("play", target);
+  }
+
+  pause(target?: string): void {
+    this.command("pause", target);
+  }
+
+  next(target?: string): void {
+    this.command("next", target);
+  }
+
+  previous(target?: string): void {
+    this.command("previous", target);
+  }
+
+  seek(target: string | undefined, positionMs: number): void {
+    this.command("seek", target, { position: positionMs });
+  }
+
+  queueJump(target: string | undefined, index: number): void {
+    this.command("queue_jump", target, { index });
+  }
+
+  queueRemove(target: string | undefined, index: number): void {
+    this.command("queue_remove", target, { index });
+  }
+
+  /** Enqueue tracks on the target device. */
+  enqueue(
+    target: string | undefined,
+    tracks: RemoteQueueItem[],
+    mode: "now" | "next" | "last" = "now",
+    shuffle = false,
+    startIndex = 0,
+  ): void {
+    this.command("enqueue", target, {
+      tracks: tracks.map((t) => ({
+        uploadId: t.uploadId,
+        trackId: t.trackId,
+        title: t.title,
+        artist: t.artist,
+        album: t.album,
+        album_artist: t.albumArtist,
+        album_art: t.albumArt,
+        duration: t.durationMs,
+        song_uri: t.songUri,
+        album_uri: t.albumUri,
+        track_number: t.trackNumber,
+      })),
+      mode,
+      shuffle,
+      startIndex,
+    });
+  }
+
+  /** Send an arbitrary command (escape hatch). */
+  command(action: string, target?: string, args?: Json): void {
+    const payload: Json = { type: "command", action, token: this.getToken() };
+    if (target) payload.target = target;
+    if (args !== undefined) payload.args = args;
+    this.send(payload);
+  }
+
+  // ── Internals ───────────────────────────────────────────────────────────────
+
+  private send(payload: Json): void {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      try {
+        this.ws.send(JSON.stringify(payload));
+      } catch (e) {
+        this.debug("send error", e);
+      }
+    }
+  }
+
+  private open(): void {
+    if (this.stopped) return;
+    const token = this.getToken();
+    if (!token) {
+      this.reconnectTimer = setTimeout(() => this.open(), this.reconnectMs);
+      return;
+    }
+
+    let ws: WebSocket;
+    try {
+      ws = new WebSocket(this.url);
+    } catch (e) {
+      this.debug("connect failed", e);
+      this.reconnectTimer = setTimeout(() => this.open(), this.reconnectMs);
+      return;
+    }
+    this.ws = ws;
+
+    ws.onopen = () => {
+      this.debug("connected");
+      this.send({ type: "register", clientName: this.opts.name, token: this.getToken() });
+      if (this.heartbeat) clearInterval(this.heartbeat);
+      this.heartbeat = setInterval(() => {
+        if (ws.readyState === WebSocket.OPEN) ws.send("ping");
+      }, this.heartbeatMs);
+    };
+
+    ws.onmessage = (ev: MessageEvent) => {
+      if (ev.data === "pong") return;
+      let msg: Json;
+      try {
+        msg = JSON.parse(ev.data as string);
+      } catch {
+        return;
+      }
+      this.handle(msg);
+    };
+
+    ws.onerror = () => {
+      try {
+        ws.close();
+      } catch {
+        /* ignore */
+      }
+    };
+
+    ws.onclose = () => {
+      this.debug("disconnected");
+      if (this.heartbeat) clearInterval(this.heartbeat);
+      if (this.ws === ws) this.ws = null;
+      if (!this.stopped) {
+        if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = setTimeout(() => this.open(), this.reconnectMs);
+      }
+    };
+  }
+
+  private handle(msg: Json): void {
+    // The registration reply carries no event (a controller doesn't need its own
+    // id to control other devices).
+    if (msg.status === "registered") return;
+    switch (msg.type) {
+      case "devices":
+        this.handlers.devices?.({
+          primaryDevice: msg.primary_device ?? null,
+          devices: (msg.devices ?? []).map(deviceFromJson),
+        });
+        break;
+      case "device_registered":
+        this.handlers.deviceRegistered?.({
+          deviceId: msg.deviceId ?? "",
+          name: msg.clientName ?? "",
+        });
+        break;
+      case "device_unregistered":
+        this.handlers.deviceUnregistered?.({ deviceId: msg.device_id ?? "" });
+        break;
+      case "primary_changed":
+        this.handlers.primaryChanged?.({ deviceId: msg.device_id ?? "" });
+        break;
+      case "message":
+        this.handleMessage(msg);
+        break;
+      default:
+        this.debug("unknown frame", msg.type);
+    }
+  }
+
+  private handleMessage(msg: Json): void {
+    const deviceId = msg.device_id ?? "";
+    const deviceName = msg.device_name ?? "";
+    const data = msg.data;
+    if (!data) return;
+    switch (data.type) {
+      case "track":
+        this.handlers.nowPlaying?.({ deviceId, deviceName, track: trackFromJson(data) });
+        break;
+      case "status":
+        this.handlers.status?.({ deviceId, deviceName, status: statusFromCode(data.status) });
+        break;
+      case "queue":
+        this.handlers.queue?.({
+          deviceId,
+          deviceName,
+          index: data.index ?? 0,
+          queue: (data.queue ?? []).map(queueItemFromJson),
+        });
+        break;
+    }
+  }
+}
+
+function statusFromCode(code: number): RemoteStatus {
+  return code === 1 ? "playing" : code === 0 ? "stopped" : "paused";
+}
+
+function trackFromJson(d: Json): RemoteNowPlaying {
+  return {
+    title: d.title ?? "",
+    artist: d.artist ?? "",
+    album: d.album,
+    albumArtist: d.album_artist,
+    albumArt: d.album_art,
+    durationMs: d.duration_ms ?? d.length,
+    elapsedMs: d.elapsed,
+    isPlaying: d.is_playing,
+  };
+}
+
+function queueItemFromJson(d: Json): RemoteQueueItem {
+  return {
+    uploadId: d.uploadId,
+    trackId: d.trackId,
+    title: d.title ?? "",
+    artist: d.artist ?? "",
+    album: d.album,
+    albumArtist: d.album_artist,
+    albumArt: d.album_art,
+    durationMs: d.duration,
+    songUri: d.song_uri,
+    albumUri: d.album_uri,
+    trackNumber: d.track_number,
+  };
+}
+
+function deviceFromJson(d: Json): RemoteDevice {
+  return {
+    deviceId: d.device_id ?? "",
+    name: d.name ?? "",
+    nowPlaying: d.now_playing ? trackFromJson(d.now_playing) : undefined,
+    queueIndex: d.queue?.index ?? 0,
+    queue: (d.queue?.queue ?? []).map(queueItemFromJson),
+  };
+}