@raphiiko/wavelink-cli 0.0.5 → 0.0.7

package/src/services/client.ts

@@ -0,0 +1,24 @@
+import { WaveLinkClient } from "@raphiiko/wavelink-ts";
+
+export async function withClient<T>(action: (client: WaveLinkClient) => Promise<T>): Promise<T> {
+  const client = new WaveLinkClient({
+    autoReconnect: false,
+  });
+
+  try {
+    console.log("Connecting to Wave Link...");
+    await client.connect();
+    console.log("Connected successfully");
+
+    return await action(client);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`Error: ${error.message}`);
+    } else {
+      console.error("An unexpected error occurred");
+    }
+    process.exit(1);
+  } finally {
+    client.disconnect();
+  }
+}

package/src/services/finders.ts

@@ -0,0 +1,150 @@
+import { WaveLinkClient } from "@raphiiko/wavelink-ts";
+import type { MixInfo, OutputInfo, InputInfo, ChannelInfo } from "../types/index.js";
+import { exitWithError } from "../utils/error.js";
+import { getChannelName } from "../utils/format.js";
+
+export async function findMixByIdOrName(
+  client: WaveLinkClient,
+  idOrName: string
+): Promise<MixInfo | null> {
+  const { mixes } = await client.getMixes();
+  const lowerIdOrName = idOrName.toLowerCase();
+  const mix = mixes.find(
+    (m) => m.id.toLowerCase() === lowerIdOrName || (m.name || "").toLowerCase() === lowerIdOrName
+  );
+  return mix ? { id: mix.id, name: mix.name || mix.id } : null;
+}
+
+export async function findChannelByIdOrName(
+  client: WaveLinkClient,
+  idOrName: string
+): Promise<ChannelInfo | null> {
+  const { channels } = await client.getChannels();
+  const lowerIdOrName = idOrName.toLowerCase();
+
+  // First try exact ID match
+  const channelById = channels.find((c) => c.id.toLowerCase() === lowerIdOrName);
+  if (channelById) {
+    return { id: channelById.id, name: getChannelName(channelById) };
+  }
+
+  // Then try name match (checking both channel.name and channel.image.name)
+  const channelByName = channels.find((c) => {
+    const name = getChannelName(c);
+    return name.toLowerCase() === lowerIdOrName;
+  });
+
+  return channelByName ? { id: channelByName.id, name: getChannelName(channelByName) } : null;
+}
+
+export async function findInputByIdOrName(
+  client: WaveLinkClient,
+  idOrName: string
+): Promise<InputInfo | null> {
+  const { inputDevices } = await client.getInputDevices();
+  const lowerIdOrName = idOrName.toLowerCase();
+
+  // First try exact ID match
+  for (const device of inputDevices) {
+    const input = device.inputs.find((i) => i.id.toLowerCase() === lowerIdOrName);
+    if (input) {
+      return {
+        deviceId: device.id,
+        deviceName: device.name || device.id,
+        inputId: input.id,
+        inputName: input.name || input.id,
+        gain: input.gain.value,
+        isMuted: input.isMuted,
+      };
+    }
+  }
+
+  // Then try name match
+  for (const device of inputDevices) {
+    const input = device.inputs.find((i) => (i.name || "").toLowerCase() === lowerIdOrName);
+    if (input) {
+      return {
+        deviceId: device.id,
+        deviceName: device.name || device.id,
+        inputId: input.id,
+        inputName: input.name || input.id,
+        gain: input.gain.value,
+        isMuted: input.isMuted,
+      };
+    }
+  }
+
+  return null;
+}
+
+export async function findOutputByIdOrName(
+  client: WaveLinkClient,
+  idOrName: string
+): Promise<OutputInfo | null> {
+  const { outputDevices } = await client.getOutputDevices();
+  const lowerIdOrName = idOrName.toLowerCase();
+
+  // First try exact ID match
+  for (const device of outputDevices) {
+    const output = device.outputs.find((o) => o.id.toLowerCase() === lowerIdOrName);
+    if (output) {
+      return {
+        deviceId: device.id,
+        outputId: output.id,
+        currentMixId: output.mixId,
+        deviceName: device.name || device.id,
+        isWaveDevice: device.isWaveDevice,
+        outputName: output.name || output.id,
+        level: output.level,
+        isMuted: output.isMuted,
+      };
+    }
+  }
+
+  // Then try name match
+  for (const device of outputDevices) {
+    const output = device.outputs.find((o) => (o.name || "").toLowerCase() === lowerIdOrName);
+    if (output) {
+      return {
+        deviceId: device.id,
+        outputId: output.id,
+        currentMixId: output.mixId,
+        deviceName: device.name || device.id,
+        isWaveDevice: device.isWaveDevice,
+        outputName: output.name || output.id,
+        level: output.level,
+        isMuted: output.isMuted,
+      };
+    }
+  }
+
+  return null;
+}
+
+// Required finder wrappers that exit on not found
+export async function requireMix(client: WaveLinkClient, mixId: string): Promise<MixInfo> {
+  const mix = await findMixByIdOrName(client, mixId);
+  if (!mix) exitWithError(`Mix '${mixId}' not found`);
+  return mix;
+}
+
+export async function requireOutput(client: WaveLinkClient, outputId: string): Promise<OutputInfo> {
+  const output = await findOutputByIdOrName(client, outputId);
+  if (!output) exitWithError(`Output '${outputId}' not found`);
+  return output;
+}
+
+export async function requireInput(client: WaveLinkClient, inputId: string): Promise<InputInfo> {
+  const input = await findInputByIdOrName(client, inputId);
+  if (!input) exitWithError(`Input '${inputId}' not found`);
+  return input;
+}
+
+export async function requireChannel(
+  client: WaveLinkClient,
+  channelId: string
+): Promise<ChannelInfo> {
+  const channel = await findChannelByIdOrName(client, channelId);
+  if (!channel) exitWithError(`Channel '${channelId}' not found`);
+  return channel;
+}

package/src/types/index.ts

@@ -0,0 +1,23 @@
+export type MixInfo = { id: string; name: string };
+
+export type OutputInfo = {
+  deviceId: string;
+  outputId: string;
+  currentMixId: string;
+  deviceName: string;
+  isWaveDevice: boolean;
+  outputName: string;
+  level: number;
+  isMuted: boolean;
+};
+
+export type InputInfo = {
+  deviceId: string;
+  deviceName: string;
+  inputId: string;
+  inputName: string;
+  gain: number;
+  isMuted: boolean;
+};
+
+export type ChannelInfo = { id: string; name: string };

package/src/utils/error.ts

@@ -0,0 +1,4 @@
+export function exitWithError(message: string): never {
+  console.error(`Error: ${message}`);
+  process.exit(1);
+}

package/src/utils/format.ts

@@ -0,0 +1,15 @@
+export function formatPercent(value: number): string {
+  return `${(value * 100).toFixed(0)}%`;
+}
+
+export function formatMuted(isMuted: boolean): string {
+  return isMuted ? "Yes" : "No";
+}
+
+export function getChannelName(channel: {
+  id: string;
+  name?: string;
+  image?: { name?: string };
+}): string {
+  return channel.name ?? channel.image?.name ?? channel.id;
+}

package/src/utils/validation.ts

@@ -0,0 +1,9 @@
+import { exitWithError } from "./error.js";
+
+export function parsePercent(value: string, name: string): number {
+  const percent = parseInt(value, 10);
+  if (isNaN(percent) || percent < 0 || percent > 100) {
+    exitWithError(`${name} must be a number between 0 and 100`);
+  }
+  return percent;
+}