@lox-audioserver/node-librespot 0.3.2

package/scripts/test-connect.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const ROOT = path.resolve(__dirname, '..');
+const DIST_ENTRY = path.join(ROOT, 'dist', 'index.js');
+
+function loadLibrary() {
+  try {
+    // eslint-disable-next-line import/no-dynamic-require, global-require
+    return require(DIST_ENTRY);
+  } catch (err) {
+    console.error(
+      'Kan dist/index.js niet laden. Draai eerst `npm run build:debug` of `npm run build` zodat het native addon beschikbaar is.',
+    );
+    throw err;
+  }
+}
+
+const { startConnectDevice, loginWithAccessToken, setLogLevel } = loadLibrary();
+
+function readCredentials(filePath) {
+  const resolved = path.resolve(filePath);
+  try {
+    return fs.readFileSync(resolved, 'utf8');
+  } catch (err) {
+    throw new Error(`Kon credentials niet lezen van ${resolved}: ${err.message}`);
+  }
+}
+
+async function resolveCredentials(deviceName) {
+  if (process.env.SPOTIFY_CREDENTIALS_JSON) {
+    return process.env.SPOTIFY_CREDENTIALS_JSON;
+  }
+
+  if (process.env.SPOTIFY_CREDENTIALS_PATH) {
+    return readCredentials(process.env.SPOTIFY_CREDENTIALS_PATH);
+  }
+
+  if (process.env.SPOTIFY_ACCESS_TOKEN) {
+    console.info('Maak credentials aan via SPOTIFY_ACCESS_TOKEN...');
+    const res = await loginWithAccessToken(process.env.SPOTIFY_ACCESS_TOKEN, deviceName);
+    console.info(`Gebruiker: ${res.username}`);
+    return res.credentialsJson;
+  }
+
+  throw new Error(
+    'Geef credentials door via SPOTIFY_CREDENTIALS_JSON, SPOTIFY_CREDENTIALS_PATH of SPOTIFY_ACCESS_TOKEN.',
+  );
+}
+
+async function main() {
+  const deviceName = process.env.SPOTIFY_DEVICE_NAME || 'node-librespot-connect';
+  const deviceId = process.env.SPOTIFY_DEVICE_ID || 'node-librespot-connect-id';
+  const durationMs =
+    Number(process.env.SPOTIFY_CONNECT_DURATION_MS || process.env.SPOTIFY_TEST_DURATION_MS) ||
+    30000;
+
+  setLogLevel(process.env.SPOTIFY_LOG_LEVEL || 'info');
+
+  const credentialsJson = await resolveCredentials(deviceName);
+  console.info(`Start Spotify Connect host voor "${deviceName}" (${deviceId})`);
+
+  let chunkCount = 0;
+  let bytes = 0;
+  let events = 0;
+
+  const handle = await startConnectDevice(
+    credentialsJson,
+    deviceName,
+    deviceId,
+    (chunk) => {
+      chunkCount += 1;
+      bytes += chunk.length;
+    },
+    (event) => {
+      events += 1;
+      if (event.type === 'error') {
+        console.error('Event (error):', event);
+      } else if (event.type !== 'metric' && event.type !== 'health') {
+        console.info('Event:', event);
+      }
+    },
+    (log) => {
+      if (log.level === 'error' || log.level === 'warn') {
+        console.info('Log:', log);
+      }
+    },
+  );
+
+  const stop = () => {
+    console.info(
+      `Stop Connect host na ~${durationMs}ms; ${chunkCount} chunks ontvangen (~${(bytes / 1024).toFixed(1)} KiB), ${events} events.`,
+    );
+    handle.stop();
+    handle.shutdown?.();
+    handle.close?.();
+  };
+
+  const timeout = setTimeout(stop, durationMs);
+
+  process.on('SIGINT', () => {
+    clearTimeout(timeout);
+    stop();
+    process.exit(1);
+  });
+}
+
+main().catch((err) => {
+  console.error('Connect test mislukt:', err);
+  process.exit(1);
+});

package/scripts/test-service.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const ROOT = path.resolve(__dirname, '..');
+const DIST_ENTRY = path.join(ROOT, 'dist', 'index.js');
+
+function loadLibrary() {
+  try {
+    // eslint-disable-next-line import/no-dynamic-require, global-require
+    return require(DIST_ENTRY);
+  } catch (err) {
+    console.error(
+      'Kan dist/index.js niet laden. Draai eerst `npm run build:debug` of `npm run build` zodat het native addon beschikbaar is.',
+    );
+    throw err;
+  }
+}
+
+const { startConnectDevice, createSession, loginWithAccessToken, setLogLevel } = loadLibrary();
+
+function readCredentials(filePath) {
+  const resolved = path.resolve(filePath);
+  try {
+    return fs.readFileSync(resolved, 'utf8');
+  } catch (err) {
+    throw new Error(`Kon credentials niet lezen van ${resolved}: ${err.message}`);
+  }
+}
+
+async function resolveCredentials(deviceName) {
+  if (process.env.SPOTIFY_CREDENTIALS_JSON) {
+    return process.env.SPOTIFY_CREDENTIALS_JSON;
+  }
+
+  if (process.env.SPOTIFY_CREDENTIALS_PATH) {
+    return readCredentials(process.env.SPOTIFY_CREDENTIALS_PATH);
+  }
+
+  if (process.env.SPOTIFY_ACCESS_TOKEN) {
+    console.info('Maak credentials aan via SPOTIFY_ACCESS_TOKEN...');
+    const res = await loginWithAccessToken(process.env.SPOTIFY_ACCESS_TOKEN, deviceName);
+    console.info(`Gebruiker: ${res.username}`);
+    return res.credentialsJson;
+  }
+
+  throw new Error(
+    'Geef credentials door via SPOTIFY_CREDENTIALS_JSON, SPOTIFY_CREDENTIALS_PATH of SPOTIFY_ACCESS_TOKEN.',
+  );
+}
+
+function scheduleRestart(attempt, fn) {
+  const restartBackoffMs = [2000, 4000, 8000];
+  const delay = restartBackoffMs[Math.min(attempt, restartBackoffMs.length - 1)];
+  console.info(`Herstart Connect host over ${delay}ms (poging ${attempt + 1})`);
+  setTimeout(fn, delay);
+}
+
+async function runConnectHost(credentialsJson, deviceName, deviceId, durationMs) {
+  let handle = null;
+  let chunkCount = 0;
+  let bytes = 0;
+  let events = 0;
+  let restartAttempt = 0;
+  let stopping = false;
+
+  const start = async () => {
+    console.info(`Start Spotify Connect host voor "${deviceName}" (${deviceId})`);
+    handle = await startConnectDevice(
+      credentialsJson,
+      deviceName,
+      deviceId,
+      (chunk) => {
+        chunkCount += 1;
+        bytes += chunk.length;
+      },
+      (event) => {
+        events += 1;
+        if (event.type === 'error') {
+          console.error('Event (error):', event);
+          if (!stopping) {
+            handle.stop();
+            handle = null;
+            scheduleRestart(restartAttempt, start);
+            restartAttempt += 1;
+          }
+          return;
+        }
+        if (event.type !== 'metric' && event.type !== 'health') {
+          console.info('Event:', event);
+        }
+      },
+      (log) => {
+        if (log.level === 'error' || log.level === 'warn') {
+          console.info('Log:', log);
+        }
+      },
+    );
+    restartAttempt = 0;
+  };
+
+  await start();
+
+  const stop = async (reason) => {
+    if (stopping) {
+      return;
+    }
+    stopping = true;
+    if (handle) {
+      try {
+        handle.stop();
+        handle.shutdown?.();
+        handle.close?.();
+      } catch {
+        /* ignore */
+      }
+    }
+    console.info(
+      `${reason}; ${chunkCount} chunks ontvangen (~${(bytes / 1024).toFixed(
+        1,
+      )} KiB), ${events} events.`,
+    );
+  };
+
+  const timeout = setTimeout(() => stop(`Stop na ${durationMs}ms`), durationMs);
+
+  process.on('SIGINT', async () => {
+    clearTimeout(timeout);
+    await stop('Stop door SIGINT');
+    process.exit(1);
+  });
+}
+
+async function runDirectStream(credentialsJson, deviceName, trackUri, durationMs) {
+  const bitrate = Number(process.env.SPOTIFY_BITRATE) || 160;
+  console.info(`Maak directe stream voor ${trackUri} op ${bitrate} kbps`);
+  const session = await createSession({ credentialsJson, deviceName });
+  let chunkCount = 0;
+  let bytes = 0;
+
+  const handle = session.streamTrack(
+    { uri: trackUri, bitrate, emitEvents: true },
+    (chunk) => {
+      chunkCount += 1;
+      bytes += chunk.length;
+    },
+    (event) => {
+      if (event.type === 'error') {
+        console.error('Event (error):', event);
+      } else if (event.type === 'metric' || event.type === 'health') {
+        console.info('Event:', event);
+      }
+    },
+    (log) => {
+      if (log.level === 'error' || log.level === 'warn') {
+        console.info('Log:', log);
+      }
+    },
+  );
+
+  const stop = async (reason) => {
+    console.info(
+      `${reason}; ${chunkCount} chunks ontvangen (~${(bytes / 1024).toFixed(1)} KiB).`,
+    );
+    handle.stop();
+    await session.close();
+  };
+
+  const timeout = setTimeout(() => stop(`Stop na ${durationMs}ms`), durationMs);
+  process.on('SIGINT', async () => {
+    clearTimeout(timeout);
+    await stop('Stop door SIGINT');
+    process.exit(1);
+  });
+}
+
+async function main() {
+  const deviceName = process.env.SPOTIFY_DEVICE_NAME || 'node-librespot-service';
+  const deviceId = process.env.SPOTIFY_DEVICE_ID || 'node-librespot-service-id';
+  const durationMs =
+    Number(process.env.SPOTIFY_SERVICE_DURATION_MS || process.env.SPOTIFY_TEST_DURATION_MS) ||
+    30000;
+  const trackUri = process.env.SPOTIFY_TRACK_URI;
+  const mode = process.env.SPOTIFY_SERVICE_MODE || (trackUri ? 'stream' : 'connect');
+
+  setLogLevel(process.env.SPOTIFY_LOG_LEVEL || 'info');
+
+  const credentialsJson = await resolveCredentials(deviceName);
+
+  if (mode === 'stream') {
+    if (!trackUri) {
+      throw new Error('Zet SPOTIFY_TRACK_URI voor stream mode.');
+    }
+    await runDirectStream(credentialsJson, deviceName, trackUri, durationMs);
+    return;
+  }
+
+  await runConnectHost(credentialsJson, deviceName, deviceId, durationMs);
+}
+
+main().catch((err) => {
+  console.error('Service test mislukt:', err);
+  process.exit(1);
+});

package/scripts/test.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const ROOT = path.resolve(__dirname, '..');
+const DIST_ENTRY = path.join(ROOT, 'dist', 'index.js');
+
+function loadLibrary() {
+  try {
+    return require(DIST_ENTRY);
+  } catch (err) {
+    console.error(
+      'Kan dist/index.js niet laden. Draai eerst `npm run build:debug` of `npm run build` zodat het native addon beschikbaar is.',
+    );
+    throw err;
+  }
+}
+
+const { createSession, loginWithAccessToken, setLogLevel } = loadLibrary();
+
+function readCredentials(filePath) {
+  const resolved = path.resolve(filePath);
+  try {
+    return fs.readFileSync(resolved, 'utf8');
+  } catch (err) {
+    throw new Error(`Kon credentials niet lezen van ${resolved}: ${err.message}`);
+  }
+}
+
+async function resolveCredentials(deviceName) {
+  if (process.env.SPOTIFY_CREDENTIALS_JSON) {
+    return process.env.SPOTIFY_CREDENTIALS_JSON;
+  }
+
+  if (process.env.SPOTIFY_CREDENTIALS_PATH) {
+    return readCredentials(process.env.SPOTIFY_CREDENTIALS_PATH);
+  }
+
+  if (process.env.SPOTIFY_ACCESS_TOKEN) {
+    console.info('Maak credentials aan via SPOTIFY_ACCESS_TOKEN...');
+    const res = await loginWithAccessToken(process.env.SPOTIFY_ACCESS_TOKEN, deviceName);
+    console.info(`Gebruiker: ${res.username}`);
+    return res.credentialsJson;
+  }
+
+  throw new Error(
+    'Geef credentials door via SPOTIFY_CREDENTIALS_JSON, SPOTIFY_CREDENTIALS_PATH of SPOTIFY_ACCESS_TOKEN.',
+  );
+}
+
+async function main() {
+  const trackUri = process.env.SPOTIFY_TRACK_URI;
+  if (!trackUri) {
+    throw new Error('Zet SPOTIFY_TRACK_URI op een Spotify track/episode URI om te testen.');
+  }
+
+  const deviceName = process.env.SPOTIFY_DEVICE_NAME || 'node-librespot-test';
+  const bitrate = Number(process.env.SPOTIFY_BITRATE) || 160;
+  const durationMs = Number(process.env.SPOTIFY_TEST_DURATION_MS) || 5000;
+
+  setLogLevel(process.env.SPOTIFY_LOG_LEVEL || 'info');
+
+  const credentialsJson = await resolveCredentials(deviceName);
+  console.info('Sessies opzetten...');
+  const session = await createSession({ credentialsJson, deviceName });
+  console.info(`Stream ${trackUri} op ${bitrate} kbps voor ~${durationMs}ms`);
+
+  let chunkCount = 0;
+  let bytes = 0;
+  const streamHandle = session.streamTrack(
+    { uri: trackUri, bitrate, emitEvents: true },
+    (chunk) => {
+      chunkCount += 1;
+      bytes += chunk.length;
+    },
+    (event) => {
+      if (event.type === 'error') {
+        console.error('Event (error):', event);
+      } else if (event.type === 'metric' || event.type === 'health') {
+        console.info('Event:', event);
+      }
+    },
+    (log) => {
+      if (log.level === 'error' || log.level === 'warn') {
+        console.info('Log:', log);
+      }
+    },
+  );
+
+  const stop = async () => {
+    console.info(
+      `Stop na ${durationMs}ms; ${chunkCount} chunks ontvangen (~${(bytes / 1024).toFixed(1)} KiB).`,
+    );
+    streamHandle.stop();
+    await session.close();
+    console.info('Klaar.');
+  };
+
+  const timeout = setTimeout(stop, durationMs);
+
+  process.on('SIGINT', async () => {
+    clearTimeout(timeout);
+    await stop();
+    process.exit(1);
+  });
+}
+
+main().catch((err) => {
+  console.error('Test mislukt:', err);
+  process.exit(1);
+});

package/scripts/update-librespot.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+repo_dir="${script_dir}/../librespot-dev"
+repo_url="https://github.com/librespot-org/librespot.git"
+
+if [[ ! -d "${repo_dir}/.git" ]]; then
+  mkdir -p "${repo_dir}"
+  git clone "${repo_url}" "${repo_dir}"
+else
+  git -C "${repo_dir}" pull --ff-only
+fi

package/src/index.ts

@@ -0,0 +1,232 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import type {
+  ConnectHandle,
+  ConnectEvent,
+  CreateSessionOpts,
+  CredentialsResult,
+  LibrespotSession,
+  LogEvent,
+  StreamHandle,
+  StreamTrackOpts,
+  DownloadTrackOpts,
+  DownloadHandle,
+} from './types';
+
+function detectLibc(): 'gnu' | 'musl' {
+  const glibcVersionRuntime =
+    // @ts-expect-error
+    process.report?.getReport?.()?.header?.glibcVersionRuntime;
+  return glibcVersionRuntime ? 'gnu' : 'musl';
+}
+
+function platformArchABI(): string {
+  const { platform, arch } = process;
+  if (platform === 'linux') {
+    return `linux-${arch}-${detectLibc()}`;
+  }
+  if (platform === 'darwin') {
+    return `darwin-${arch}`;
+  }
+  if (platform === 'win32') {
+    return `win32-${arch}-msvc`;
+  }
+  throw new Error(`Unsupported platform ${platform}-${arch}`);
+}
+
+function resolveNativeBinding() {
+  const override = process.env.LOX_LIBRESPOT_ADDON_PATH;
+  if (override && fs.existsSync(override)) {
+    return override;
+  }
+
+  const prebuiltPath = path.join(
+    __dirname,
+    '..',
+    'prebuilds',
+    platformArchABI(),
+    'librespot_addon.node',
+  );
+  if (fs.existsSync(prebuiltPath)) {
+    return prebuiltPath;
+  }
+
+  const localBuildPath = path.join(__dirname, 'librespot_addon.node');
+  if (fs.existsSync(localBuildPath)) {
+    return localBuildPath;
+  }
+
+  throw new Error(
+    `librespot_addon.node not found for ${platformArchABI()}. ` +
+    'Install a prebuilt binary, build locally with "npm run build", ' +
+    'or point LOX_LIBRESPOT_ADDON_PATH to the compiled addon.',
+  );
+}
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const native = require(resolveNativeBinding()) as {
+  createSession(opts: CreateSessionOpts): 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>;
+  startConnectDeviceWithToken(
+    accessToken: string,
+    clientId: string | undefined,
+    name: string,
+    deviceId: string,
+    onChunk: (chunk: Buffer) => void,
+    onEvent?: (event: ConnectEvent) => void,
+    onLog?: (event: LogEvent) => void,
+  ): Promise<ConnectHandle>;
+};
+
+function wrapStreamHandle(handle: StreamHandle) {
+  return {
+    stop: () => handle.stop(),
+    get sampleRate() {
+      return (handle as any).sampleRate ?? (handle as any).sample_rate ?? handle.sampleRate;
+    },
+    get channels() {
+      return (handle as any).channels ?? handle.channels;
+    },
+  };
+}
+
+function wrapSession(session: LibrespotSession) {
+  return {
+    streamTrack: (
+      opts: StreamTrackOpts,
+      onChunk: (chunk: Buffer) => void,
+      onEvent?: (event: ConnectEvent) => void,
+      onLog?: (event: LogEvent) => void,
+    ) => {
+      const nativeOpts = {
+        uri: opts.uri,
+        startPositionMs: (opts as any).startPositionMs ?? (opts as any).start_position_ms,
+        bitrate: opts.bitrate,
+        output: (opts as any).output,
+        emitEvents: (opts as any).emitEvents ?? (opts as any).emit_events,
+      };
+      const handle = (session as any).streamTrack(nativeOpts, onChunk, onEvent, onLog);
+      return wrapStreamHandle(handle);
+    },
+    close: () => session.close(),
+  };
+}
+
+export function createSession(opts: CreateSessionOpts): Promise<LibrespotSession> {
+  const nativeOpts = {
+    accessToken: (opts as any).accessToken ?? (opts as any).access_token,
+    clientId: (opts as any).clientId ?? (opts as any).client_id,
+    deviceName: (opts as any).deviceName ?? (opts as any).device_name,
+  };
+  return native.createSession(nativeOpts as CreateSessionOpts).then((sess) => wrapSession(sess) as any);
+}
+
+export function loginWithAccessToken(
+  accessToken: string,
+  deviceName?: string,
+): Promise<CredentialsResult> {
+  return native.loginWithAccessToken(accessToken, deviceName).then((res: any) => {
+    const credentialsJson = res.credentialsJson ?? res.credentials_json;
+    return {
+      ...res,
+      credentialsJson,
+      credentials_json: credentialsJson ?? res.credentials_json,
+    };
+  });
+}
+
+export function startZeroconfLogin(
+  deviceId: string,
+  name?: string,
+  timeoutMs?: number,
+): Promise<CredentialsResult> {
+  return native.startZeroconfLogin(deviceId, name, timeoutMs).then((res: any) => {
+    const credentialsJson = res.credentialsJson ?? res.credentials_json;
+    return {
+      ...res,
+      credentialsJson,
+      credentials_json: credentialsJson ?? res.credentials_json,
+    };
+  });
+}
+
+export function startConnectDevice(
+  credentialsPath: string,
+  name: string,
+  deviceId: string,
+  onChunk: (chunk: Buffer) => void,
+  onEvent?: (event: ConnectEvent) => void,
+  onLog?: (event: LogEvent) => void,
+): Promise<ConnectHandle> {
+  // Legacy entrypoint kept for API compatibility; immediately fails.
+  return Promise.reject(
+    new Error('startConnectDevice is deprecated; use startConnectDeviceWithToken(accessToken, clientId, ...)'),
+  );
+}
+
+export 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> {
+  return Promise.resolve(
+    native.startConnectDeviceWithToken(accessToken, clientId, 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 setLogLevel(level: string): void {
+  native.setLogLevel(level);
+}
+
+export function downloadTrack(
+  opts: DownloadTrackOpts,
+  onChunk: (chunk: Buffer) => void,
+  onLog?: (event: LogEvent) => void,
+): Promise<DownloadHandle> {
+  const nativeOpts = {
+    uri: opts.uri,
+    bitrate: opts.bitrate,
+  };
+  return native.downloadTrack(nativeOpts, onChunk, onLog);
+}
+
+// Export raw native binding for advanced use/debugging.
+export { native };
+export * from './types';