@lox-audioserver/node-librespot 0.3.2 → 0.3.4

package/Cargo.lock

@@ -1220,6 +1220,7 @@ dependencies = [
  "tokio-util",
  "url",
  "uuid",
+ "vergen",
  "vergen-gitcl",
 ]
 

package/dist/index.d.ts

@@ -1,17 +1,21 @@
 import type { ConnectHandle, ConnectEvent, CreateSessionOpts, CredentialsResult, LibrespotSession, LogEvent, DownloadTrackOpts, DownloadHandle } from './types';
 declare const native: {
     createSession(opts: CreateSessionOpts): Promise<LibrespotSession>;
+    createSessionWithCredentials(credentialsPath: string, deviceName?: string | null): Promise<LibrespotSession>;
     setLogLevel(level: string): void;
     loginWithAccessToken(accessToken: string, deviceName?: string): Promise<CredentialsResult>;
     downloadTrack(opts: DownloadTrackOpts, onChunk: (chunk: Buffer) => void, onLog?: (event: LogEvent) => void): Promise<DownloadHandle>;
     startZeroconfLogin(deviceId: string, name?: string | null, timeoutMs?: number | null): Promise<CredentialsResult>;
     startConnectDevice(credentialsPath: string, name: string, deviceId: string, onChunk: (chunk: Buffer) => void, onEvent?: (event: ConnectEvent) => void, onLog?: (event: LogEvent) => void): Promise<ConnectHandle>;
+    startConnectDeviceWithCredentials(credentialsPath: string, name: string, deviceId: string, onChunk: (chunk: Buffer) => void, onEvent?: (event: ConnectEvent) => void, onLog?: (event: LogEvent) => void): Promise<ConnectHandle>;
     startConnectDeviceWithToken(accessToken: string, clientId: string | undefined, name: string, deviceId: string, onChunk: (chunk: Buffer) => void, onEvent?: (event: ConnectEvent) => void, onLog?: (event: LogEvent) => void): Promise<ConnectHandle>;
 };
 export declare function createSession(opts: CreateSessionOpts): Promise<LibrespotSession>;
+export declare function createSessionWithCredentials(credentialsPathOrJson: string, deviceName?: string | null): Promise<LibrespotSession>;
 export declare function loginWithAccessToken(accessToken: string, deviceName?: string): Promise<CredentialsResult>;
 export declare function startZeroconfLogin(deviceId: string, name?: string, timeoutMs?: number): Promise<CredentialsResult>;
 export declare function startConnectDevice(credentialsPath: string, name: string, deviceId: string, onChunk: (chunk: Buffer) => void, onEvent?: (event: ConnectEvent) => void, onLog?: (event: LogEvent) => void): Promise<ConnectHandle>;
+export declare function startConnectDeviceWithCredentials(credentialsPathOrJson: string, name: string, deviceId: string, onChunk: (chunk: Buffer) => void, onEvent?: (event: ConnectEvent) => void, onLog?: (event: LogEvent) => void): Promise<ConnectHandle>;
 export declare function startConnectDeviceWithToken(accessToken: string, clientId: string | undefined, name: string, deviceId: string, onChunk: (chunk: Buffer) => void, onEvent?: (event: ConnectEvent) => void, onLog?: (event: LogEvent) => void): Promise<ConnectHandle>;
 export declare function setLogLevel(level: string): void;
 export declare function downloadTrack(opts: DownloadTrackOpts, onChunk: (chunk: Buffer) => void, onLog?: (event: LogEvent) => void): Promise<DownloadHandle>;

package/dist/index.js

@@ -19,9 +19,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.native = void 0;
 exports.createSession = createSession;
+exports.createSessionWithCredentials = createSessionWithCredentials;
 exports.loginWithAccessToken = loginWithAccessToken;
 exports.startZeroconfLogin = startZeroconfLogin;
 exports.startConnectDevice = startConnectDevice;
+exports.startConnectDeviceWithCredentials = startConnectDeviceWithCredentials;
 exports.startConnectDeviceWithToken = startConnectDeviceWithToken;
 exports.setLogLevel = setLogLevel;
 exports.downloadTrack = downloadTrack;
@@ -101,6 +103,11 @@ function createSession(opts) {
     };
     return native.createSession(nativeOpts).then((sess) => wrapSession(sess));
 }
+function createSessionWithCredentials(credentialsPathOrJson, deviceName) {
+    return native
+        .createSessionWithCredentials(credentialsPathOrJson, deviceName ?? null)
+        .then((sess) => wrapSession(sess));
+}
 function loginWithAccessToken(accessToken, deviceName) {
     return native.loginWithAccessToken(accessToken, deviceName).then((res) => {
         const credentialsJson = res.credentialsJson ?? res.credentials_json;
@@ -125,6 +132,19 @@ function startConnectDevice(credentialsPath, name, deviceId, onChunk, onEvent, o
     // Legacy entrypoint kept for API compatibility; immediately fails.
     return Promise.reject(new Error('startConnectDevice is deprecated; use startConnectDeviceWithToken(accessToken, clientId, ...)'));
 }
+function startConnectDeviceWithCredentials(credentialsPathOrJson, name, deviceId, onChunk, onEvent, onLog) {
+    return Promise.resolve(native.startConnectDeviceWithCredentials(credentialsPathOrJson, name, deviceId, onChunk, onEvent, onLog)).then((handle) => ({
+        stop: () => handle.stop(),
+        shutdown: () => handle.shutdown(),
+        close: () => handle.close(),
+        play: () => handle.play(),
+        pause: () => handle.pause(),
+        next: () => handle.next(),
+        prev: () => handle.prev(),
+        sampleRate: handle.sampleRate ?? handle.sample_rate ?? handle.sampleRate,
+        channels: handle.channels,
+    }));
+}
 function startConnectDeviceWithToken(accessToken, clientId, name, deviceId, onChunk, onEvent, onLog) {
     return Promise.resolve(native.startConnectDeviceWithToken(accessToken, clientId, name, deviceId, onChunk, onEvent, onLog)).then((handle) => ({
         stop: () => handle.stop(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lox-audioserver/node-librespot",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Node.js bindings for librespot (Spotify Connect) via N-API with prebuild support.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -39,7 +39,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/lox-audioserver/node-librespot"
+    "url": "git+https://github.com/lox-audioserver/node-librespot.git"
   },
   "author": "Rudy Berends",
   "license": "Apache-2.0",

package/src/index.ts

@@ -67,6 +67,10 @@ function resolveNativeBinding() {
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const native = require(resolveNativeBinding()) as {
   createSession(opts: CreateSessionOpts): Promise<LibrespotSession>;
+  createSessionWithCredentials(
+    credentialsPath: string,
+    deviceName?: string | null,
+  ): Promise<LibrespotSession>;
   setLogLevel(level: string): void;
   loginWithAccessToken(
     accessToken: string,
@@ -90,6 +94,14 @@ const native = require(resolveNativeBinding()) as {
     onEvent?: (event: ConnectEvent) => void,
     onLog?: (event: LogEvent) => void,
   ): Promise<ConnectHandle>;
+  startConnectDeviceWithCredentials(
+    credentialsPath: string,
+    name: string,
+    deviceId: string,
+    onChunk: (chunk: Buffer) => void,
+    onEvent?: (event: ConnectEvent) => void,
+    onLog?: (event: LogEvent) => void,
+  ): Promise<ConnectHandle>;
   startConnectDeviceWithToken(
     accessToken: string,
     clientId: string | undefined,
@@ -144,6 +156,15 @@ export function createSession(opts: CreateSessionOpts): Promise<LibrespotSession
   return native.createSession(nativeOpts as CreateSessionOpts).then((sess) => wrapSession(sess) as any);
 }
 
+export function createSessionWithCredentials(
+  credentialsPathOrJson: string,
+  deviceName?: string | null,
+): Promise<LibrespotSession> {
+  return native
+    .createSessionWithCredentials(credentialsPathOrJson, deviceName ?? null)
+    .then((sess) => wrapSession(sess) as any);
+}
+
 export function loginWithAccessToken(
   accessToken: string,
   deviceName?: string,
@@ -187,6 +208,29 @@ export function startConnectDevice(
   );
 }
 
+export function startConnectDeviceWithCredentials(
+  credentialsPathOrJson: string,
+  name: string,
+  deviceId: string,
+  onChunk: (chunk: Buffer) => void,
+  onEvent?: (event: ConnectEvent) => void,
+  onLog?: (event: LogEvent) => void,
+): Promise<ConnectHandle> {
+  return Promise.resolve(
+    native.startConnectDeviceWithCredentials(credentialsPathOrJson, name, deviceId, onChunk, onEvent, onLog),
+  ).then((handle: ConnectHandle & { sample_rate?: number }) => ({
+    stop: () => handle.stop(),
+    shutdown: () => handle.shutdown(),
+    close: () => handle.close(),
+    play: () => handle.play(),
+    pause: () => handle.pause(),
+    next: () => handle.next(),
+    prev: () => handle.prev(),
+    sampleRate: (handle as any).sampleRate ?? (handle as any).sample_rate ?? (handle as any).sampleRate,
+    channels: (handle as any).channels,
+  }));
+}
+
 export function startConnectDeviceWithToken(
   accessToken: string,
   clientId: string | undefined,

package/src/lib.rs

@@ -550,6 +550,7 @@ impl Sink for ChannelSink {
             self.last_pcm_at.store(now_ms, Ordering::Release);
         }
         // Pacing: throttle to approximate realtime based on sample count.
+        // Send first chunk immediately to minimize startup latency; apply pacing after forwarding.
         let bytes_per_sample = match self.format {
             AudioFormat::S24 => 3,
             AudioFormat::S32 | AudioFormat::F32 => 4,
@@ -557,19 +558,17 @@ impl Sink for ChannelSink {
         };
         let samples = bytes.len() / (bytes_per_sample * self.channels as usize);
         let duration = Duration::from_secs_f64(samples as f64 / self.sample_rate as f64);
+        if self.tx.try_send(bytes).is_err() {
+            // Drop chunk if JS side is backpressured to avoid blocking the player thread.
+        }
         let start = self.start.get_or_insert_with(Instant::now);
         self.expected_elapsed += duration;
         let target = *start + self.expected_elapsed;
         let now = Instant::now();
         let sleep_dur = target.saturating_duration_since(now);
-
         if !sleep_dur.is_zero() {
             sleep(sleep_dur);
         }
-
-        if self.tx.try_send(bytes).is_err() {
-            // Drop chunk if JS side is backpressured to avoid blocking the player thread.
-        }
         Ok(())
     }
 }
@@ -1505,6 +1504,58 @@ pub async fn create_session(opts: CreateSessionOpts) -> Result<LibrespotSession>
     })
 }
 
+/// Create a session using a reusable librespot credentials blob (JSON) or a path to credentials.json.
+///
+/// This avoids relying on a Web API access token for streaming.
+#[napi]
+pub async fn create_session_with_credentials(
+    credentials_path: String,
+    device_name: Option<String>,
+) -> Result<LibrespotSession> {
+    if credentials_path.trim().is_empty() {
+        return Err(Error::from_reason("credentials payload is required"));
+    }
+
+    let credentials: Credentials = if Path::new(&credentials_path).exists() {
+        let mut file =
+            File::open(&credentials_path).map_err(|e| Error::from_reason(format!("{e}")))?;
+        let mut buf = String::new();
+        file.read_to_string(&mut buf)
+            .map_err(|e| Error::from_reason(format!("{e}")))?;
+        serde_json::from_str(&buf)
+            .map_err(|e| Error::from_reason(format!("invalid credentials json: {e}")))?
+    } else {
+        serde_json::from_str(&credentials_path)
+            .map_err(|e| Error::from_reason(format!("invalid credentials json: {e}")))?
+    };
+
+    let mut session_config = SessionConfig::default();
+    let mut device_id = device_name.unwrap_or_else(|| "librespot".to_string());
+    if device_id.trim().is_empty() {
+        device_id = "librespot".to_string();
+    }
+    session_config.device_id = device_id.clone();
+    if let Ok(client_id_override) = std::env::var("LOX_LIBRESPOT_CLIENT_ID") {
+        if !client_id_override.trim().is_empty() {
+            session_config.client_id = client_id_override;
+        }
+    }
+
+    let session = Session::new(session_config, None);
+    session
+        .connect(credentials, false)
+        .await
+        .map_err(|e| Error::from_reason(format!("session connect failed: {e}")))?;
+
+    let player_config = PlayerConfig::default();
+
+    Ok(LibrespotSession {
+        session,
+        player_config,
+        device_id,
+    })
+}
+
 /// Internal helper to start a Spotify Connect device using provided credentials.
 /// Accepts credentials (typically created from an OAuth access token) and is shared by the
 /// token-based public entrypoint.
@@ -1646,6 +1697,7 @@ fn start_connect_device_inner(
             name: name.clone(),
             device_type: DeviceType::Speaker,
             is_group: false,
+            emit_set_queue_events: false,
             // Start with full volume so we rely on zone-side volume control; we do not sync Spotify volume.
             // Spotify volume scale is 0..65535; use max to avoid muted start.
             initial_volume: u16::MAX,
@@ -2130,6 +2182,32 @@ pub fn start_connect_device(
     ))
 }
 
+/// Start a Spotify Connect device using an existing credentials JSON blob (or a path to credentials.json).
+///
+/// This avoids exchanging a Web API token for credentials, and allows reusing credentials minted via
+/// Zeroconf or other flows.
+#[napi]
+pub fn start_connect_device_with_credentials(
+    credentials_path: String,
+    name: String,
+    device_id: String,
+    on_chunk: JsFunction,
+    on_event: Option<JsFunction>,
+    on_log: Option<JsFunction>,
+) -> Result<ConnectHandle> {
+    if credentials_path.trim().is_empty() {
+        return Err(Error::from_reason("credentials payload is required"));
+    }
+    start_connect_device_inner(
+        credentials_path,
+        name,
+        device_id,
+        on_chunk,
+        on_event,
+        on_log,
+    )
+}
+
 /// Start a Spotify Connect device using a Web API access token + client id (bypasses builtin login).
 #[napi]
 pub fn start_connect_device_with_token(