@rocksky/sdk 0.10.1 → 0.10.2

package/dist/remote.d.ts

@@ -0,0 +1,3 @@
+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";
+//# sourceMappingURL=remote.d.ts.map

package/dist/remote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote.d.ts","sourceRoot":"","sources":["../src/remote.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,YAAY,EACZ,iBAAiB,EACjB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,cAAc,GACpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,gBAAgB,EAChB,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAC3B,KAAK,YAAY,EACjB,KAAK,YAAY,GAClB,MAAM,wBAAwB,CAAC"}

package/dist/remote.js

@@ -0,0 +1,529 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/remote-player.ts
+var DEFAULT_REMOTE_WS = "wss://api.rocksky.app/ws";
+
+class RemotePlayer {
+  opts;
+  ws = null;
+  deviceId = "";
+  stopped = false;
+  heartbeat;
+  reconnectTimer;
+  url;
+  heartbeatMs;
+  reconnectMs;
+  getToken;
+  debug;
+  handlers = {};
+  lastTrack = null;
+  lastStatus = null;
+  lastQueue = null;
+  constructor(opts) {
+    this.opts = opts;
+    this.url = opts.url ?? DEFAULT_REMOTE_WS;
+    this.heartbeatMs = opts.heartbeatMs ?? 1e4;
+    this.reconnectMs = opts.reconnectMs ?? 3000;
+    this.getToken = typeof opts.token === "function" ? opts.token : () => opts.token;
+    this.debug = opts.debug ?? (() => {});
+  }
+  on(event, handler) {
+    this.handlers[event] = handler;
+    return this;
+  }
+  get id() {
+    return this.deviceId;
+  }
+  connect() {
+    this.stopped = false;
+    this.open();
+  }
+  disconnect() {
+    this.stopped = true;
+    if (this.reconnectTimer)
+      clearTimeout(this.reconnectTimer);
+    if (this.heartbeat)
+      clearInterval(this.heartbeat);
+    try {
+      this.ws?.close();
+    } catch {}
+    this.ws = null;
+  }
+  setNowPlaying(track) {
+    this.lastTrack = track;
+    this.send({
+      type: "message",
+      device_id: this.deviceId,
+      token: this.getToken(),
+      data: {
+        type: "track",
+        title: track.title,
+        artist: track.artist,
+        album: track.album,
+        album_artist: track.albumArtist ?? track.artist,
+        length: track.durationMs ?? 0,
+        elapsed: track.elapsedMs ?? 0,
+        duration_ms: track.durationMs ?? 0,
+        album_art: track.albumArt,
+        is_playing: track.isPlaying ?? true,
+        device_name: this.opts.name
+      }
+    });
+  }
+  setStatus(status) {
+    const code = status === "playing" ? 1 : status === "paused" ? 2 : 0;
+    this.lastStatus = code;
+    this.send({
+      type: "message",
+      device_id: this.deviceId,
+      token: this.getToken(),
+      data: { type: "status", status: code }
+    });
+  }
+  setQueue(items, index) {
+    this.lastQueue = { items, index };
+    this.send({
+      type: "message",
+      device_id: this.deviceId,
+      token: this.getToken(),
+      data: {
+        type: "queue",
+        index,
+        queue: items.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
+        }))
+      }
+    });
+  }
+  send(payload) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      try {
+        this.ws.send(JSON.stringify(payload));
+      } catch (e) {
+        this.debug("send error", e);
+      }
+    }
+  }
+  open() {
+    if (this.stopped)
+      return;
+    const token = this.getToken();
+    if (!token) {
+      this.reconnectTimer = setTimeout(() => this.open(), this.reconnectMs);
+      return;
+    }
+    let ws;
+    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) => {
+      if (ev.data === "pong")
+        return;
+      let msg;
+      try {
+        msg = JSON.parse(ev.data);
+      } catch {
+        return;
+      }
+      this.handle(msg);
+    };
+    ws.onerror = () => {
+      try {
+        ws.close();
+      } catch {}
+    };
+    ws.onclose = () => {
+      this.debug("disconnected");
+      if (this.heartbeat)
+        clearInterval(this.heartbeat);
+      if (this.ws === ws)
+        this.ws = null;
+      this.deviceId = "";
+      if (!this.stopped) {
+        if (this.reconnectTimer)
+          clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = setTimeout(() => this.open(), this.reconnectMs);
+      }
+    };
+  }
+  handle(msg) {
+    if (msg.status === "registered" && typeof msg.deviceId === "string") {
+      this.deviceId = msg.deviceId;
+      this.debug("registered", this.deviceId);
+      this.resync();
+      return;
+    }
+    if (msg.type === "command") {
+      this.dispatch(msg);
+      return;
+    }
+  }
+  dispatch(msg) {
+    const h = this.handlers;
+    switch (msg.action) {
+      case "play":
+        h.play?.();
+        break;
+      case "pause":
+        h.pause?.();
+        break;
+      case "next":
+        h.next?.();
+        break;
+      case "previous":
+        h.previous?.();
+        break;
+      case "seek": {
+        const a = msg.args;
+        const pos = typeof a === "number" ? a : a?.position ?? 0;
+        h.seek?.(pos);
+        break;
+      }
+      case "queue_jump":
+        h.queueJump?.(msg.args?.index ?? 0);
+        break;
+      case "queue_remove":
+        h.queueRemove?.(msg.args?.index ?? 0);
+        break;
+      case "enqueue": {
+        const a = msg.args ?? {};
+        h.enqueue?.({
+          tracks: (a.tracks ?? []).map(descriptorToItem),
+          mode: a.mode ?? "now",
+          shuffle: !!a.shuffle,
+          startIndex: a.startIndex ?? 0
+        });
+        break;
+      }
+      default:
+        this.debug("unknown command", msg.action);
+    }
+  }
+  resync() {
+    if (this.lastTrack)
+      this.setNowPlaying(this.lastTrack);
+    if (this.lastStatus !== null) {
+      this.send({
+        type: "message",
+        device_id: this.deviceId,
+        token: this.getToken(),
+        data: { type: "status", status: this.lastStatus }
+      });
+    }
+    if (this.lastQueue)
+      this.setQueue(this.lastQueue.items, this.lastQueue.index);
+  }
+}
+function descriptorToItem(d) {
+  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
+  };
+}
+// src/remote-controller.ts
+class RemoteController {
+  opts;
+  ws = null;
+  stopped = false;
+  heartbeat;
+  reconnectTimer;
+  url;
+  heartbeatMs;
+  reconnectMs;
+  getToken;
+  debug;
+  handlers = {};
+  constructor(opts) {
+    this.opts = opts;
+    this.url = opts.url ?? DEFAULT_REMOTE_WS;
+    this.heartbeatMs = opts.heartbeatMs ?? 1e4;
+    this.reconnectMs = opts.reconnectMs ?? 3000;
+    this.getToken = typeof opts.token === "function" ? opts.token : () => opts.token;
+    this.debug = opts.debug ?? (() => {});
+  }
+  on(event, handler) {
+    this.handlers[event] = handler;
+    return this;
+  }
+  connect() {
+    this.stopped = false;
+    this.open();
+  }
+  disconnect() {
+    this.stopped = true;
+    if (this.reconnectTimer)
+      clearTimeout(this.reconnectTimer);
+    if (this.heartbeat)
+      clearInterval(this.heartbeat);
+    try {
+      this.ws?.close();
+    } catch {}
+    this.ws = null;
+  }
+  setPrimary(deviceId) {
+    this.send({ type: "set_primary", device_id: deviceId, token: this.getToken() });
+  }
+  play(target) {
+    this.command("play", target);
+  }
+  pause(target) {
+    this.command("pause", target);
+  }
+  next(target) {
+    this.command("next", target);
+  }
+  previous(target) {
+    this.command("previous", target);
+  }
+  seek(target, positionMs) {
+    this.command("seek", target, { position: positionMs });
+  }
+  queueJump(target, index) {
+    this.command("queue_jump", target, { index });
+  }
+  queueRemove(target, index) {
+    this.command("queue_remove", target, { index });
+  }
+  enqueue(target, tracks, mode = "now", shuffle = false, startIndex = 0) {
+    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
+    });
+  }
+  command(action, target, args) {
+    const payload = { type: "command", action, token: this.getToken() };
+    if (target)
+      payload.target = target;
+    if (args !== undefined)
+      payload.args = args;
+    this.send(payload);
+  }
+  send(payload) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      try {
+        this.ws.send(JSON.stringify(payload));
+      } catch (e) {
+        this.debug("send error", e);
+      }
+    }
+  }
+  open() {
+    if (this.stopped)
+      return;
+    const token = this.getToken();
+    if (!token) {
+      this.reconnectTimer = setTimeout(() => this.open(), this.reconnectMs);
+      return;
+    }
+    let ws;
+    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) => {
+      if (ev.data === "pong")
+        return;
+      let msg;
+      try {
+        msg = JSON.parse(ev.data);
+      } catch {
+        return;
+      }
+      this.handle(msg);
+    };
+    ws.onerror = () => {
+      try {
+        ws.close();
+      } catch {}
+    };
+    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);
+      }
+    };
+  }
+  handle(msg) {
+    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);
+    }
+  }
+  handleMessage(msg) {
+    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) {
+  return code === 1 ? "playing" : code === 0 ? "stopped" : "paused";
+}
+function trackFromJson(d) {
+  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,
+    songUri: d.song_uri,
+    albumUri: d.album_uri,
+    artistUri: d.artist_uri,
+    sha256: d.sha256,
+    liked: d.liked
+  };
+}
+function queueItemFromJson(d) {
+  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) {
+  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)
+  };
+}
+export {
+  RemotePlayer,
+  RemoteController,
+  DEFAULT_REMOTE_WS
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rocksky/sdk",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "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": {
@@ -21,6 +21,11 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
+    },
+    "./remote": {
+      "types": "./dist/remote.d.ts",
+      "import": "./dist/remote.js",
+      "default": "./dist/remote.js"
     }
   },
   "files": [
@@ -29,7 +34,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "bun build ./src/index.ts --outdir ./dist --target node --format esm --packages external && bun run build:types",
+    "build": "bun build ./src/index.ts ./src/remote.ts --outdir ./dist --target node --format esm --packages external && bun run build:types",
     "build:types": "tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
     "test": "bun test",

package/src/remote.ts

@@ -0,0 +1,23 @@
+// Browser-safe entry: the remote-control player + controller only.
+//
+// The main entry (`@rocksky/sdk`) bundles the dedup index (classic-level) and
+// the identity hashes (node:crypto), which are Node-only. The remote player /
+// controller are pure WebSocket + JSON with zero Node dependencies, so this
+// subpath (`@rocksky/sdk/remote`) is safe to import from a browser bundle.
+
+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";