@raphiiko/wavelink-cli 0.0.5 → 0.0.7

package/package.json

@@ -1,58 +1,58 @@
-{
-  "name": "@raphiiko/wavelink-cli",
-  "version": "0.0.5",
-  "description": "Command line interface for Elgato Wave Link 3.0",
-  "author": "Raphiiko",
-  "license": "MIT",
-  "homepage": "https://github.com/Raphiiko/wavelink-cli",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Raphiiko/wavelink-cli.git"
-  },
-  "bugs": {
-    "url": "https://github.com/Raphiiko/wavelink-cli/issues"
-  },
-  "keywords": [
-    "wavelink",
-    "cli",
-    "typescript"
-  ],
-  "main": "dist/index.js",
-  "module": "dist/index.js",
-  "type": "module",
-  "bin": {
-    "wavelink-cli": "dist/index.js"
-  },
-  "files": [
-    "dist",
-    "src"
-  ],
-  "scripts": {
-    "build": "bun build ./src/index.ts --target=node --outfile dist/index.js",
-    "start": "bun run src/index.ts",
-    "format": "prettier --write \"src/**/*.ts\"",
-    "format:check": "prettier --check \"src/**/*.ts\"",
-    "lint": "eslint src/**/*.ts",
-    "lint:fix": "eslint src/**/*.ts --fix",
-    "typecheck": "tsc --noEmit",
-    "check": "bun run format:check && bun run lint && bun run typecheck",
-    "prepublishOnly": "bun run build && bun run check"
-  },
-  "devDependencies": {
-    "@types/bun": "latest",
-    "@typescript-eslint/eslint-plugin": "^8.52.0",
-    "@typescript-eslint/parser": "^8.52.0",
-    "eslint": "^9.39.2",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-prettier": "^5.5.4",
-    "prettier": "^3.7.4",
-    "typescript": "^5"
-  },
-  "peerDependencies": {
-    "typescript": "^5"
-  },
-  "dependencies": {
-    "@raphiiko/wavelink-ts": "^1.1.0",
-    "commander": "^14.0.2"
-  }
+{
+  "name": "@raphiiko/wavelink-cli",
+  "version": "0.0.7",
+  "description": "Command line interface for Elgato Wave Link 3.0",
+  "author": "Raphiiko",
+  "license": "MIT",
+  "homepage": "https://github.com/Raphiiko/wavelink-cli",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Raphiiko/wavelink-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Raphiiko/wavelink-cli/issues"
+  },
+  "keywords": [
+    "wavelink",
+    "cli",
+    "typescript"
+  ],
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "wavelink-cli": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "bun run scripts/build.js",
+    "start": "bun run src/index.ts",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\"",
+    "lint": "eslint src/**/*.ts",
+    "lint:fix": "eslint src/**/*.ts --fix",
+    "typecheck": "tsc --noEmit",
+    "check": "bun run format:check && bun run lint && bun run typecheck",
+    "prepublishOnly": "bun run build && bun run check"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@typescript-eslint/eslint-plugin": "^8.52.0",
+    "@typescript-eslint/parser": "^8.52.0",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "prettier": "^3.7.4",
+    "typescript": "^5"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@raphiiko/wavelink-ts": "^1.3.0",
+    "commander": "^14.0.2"
+  }
 }

package/src/commands/channel.ts

@@ -0,0 +1,243 @@
+import { WaveLinkClient } from "@raphiiko/wavelink-ts";
+import { Argument, Command } from "commander";
+import { withClient } from "../services/client.js";
+import { requireChannel, requireMix } from "../services/finders.js";
+import { formatPercent, formatMuted, getChannelName } from "../utils/format.js";
+import { parsePercent } from "../utils/validation.js";
+import { exitWithError } from "../utils/error.js";
+
+export async function listChannels(client: WaveLinkClient): Promise<void> {
+  const { channels } = await client.getChannels();
+
+  console.log("\n=== Channels ===\n");
+
+  if (channels.length === 0) {
+    console.log("No channels found.");
+    return;
+  }
+
+  for (const channel of channels) {
+    const channelName = getChannelName(channel);
+    console.log(`Channel: ${channelName}`);
+    console.log(`  ID: ${channel.id}`);
+    console.log(`  Type: ${channel.type}`);
+    console.log(`  Level: ${formatPercent(channel.level)}`);
+    console.log(`  Muted: ${formatMuted(channel.isMuted)}`);
+
+    if (channel.apps?.length) {
+      console.log(`  Apps: ${channel.apps.map((a) => a.name || a.id).join(", ")}`);
+    }
+
+    if (channel.mixes?.length) {
+      console.log("  Mix Assignments:");
+      for (const mix of channel.mixes) {
+        console.log(
+          `    ${mix.id}: Level ${formatPercent(mix.level)}, Muted: ${formatMuted(mix.isMuted)}`
+        );
+      }
+    }
+    console.log();
+  }
+}
+
+export function registerChannelCommands(program: Command): void {
+  const channelCmd = program.command("channel").description("Manage channels");
+
+  channelCmd
+    .command("list")
+    .description("List all channels with their IDs and names")
+    .action(() => withClient(listChannels));
+
+  channelCmd
+    .command("set-volume")
+    .description("Set channel master volume")
+    .addArgument(
+      new Argument("<channel-id-or-name>", "ID or name of the channel (case-insensitive)")
+    )
+    .addArgument(new Argument("<volume>", "Volume level (0-100)"))
+    .action((channelId: string, volume: string) => {
+      const volumePercent = parsePercent(volume, "Volume");
+      return withClient(async (client) => {
+        const channel = await requireChannel(client, channelId);
+        await client.setChannelVolume(channel.id, volumePercent / 100);
+        console.log(`Successfully set channel '${channel.name}' volume to ${volumePercent}%`);
+      });
+    });
+
+  channelCmd
+    .command("mute")
+    .description("Mute a channel")
+    .addArgument(
+      new Argument("<channel-id-or-name>", "ID or name of the channel (case-insensitive)")
+    )
+    .action((channelId: string) =>
+      withClient(async (client) => {
+        const channel = await requireChannel(client, channelId);
+        await client.setChannelMute(channel.id, true);
+        console.log(`Successfully muted channel '${channel.name}'`);
+      })
+    );
+
+  channelCmd
+    .command("unmute")
+    .description("Unmute a channel")
+    .addArgument(
+      new Argument("<channel-id-or-name>", "ID or name of the channel (case-insensitive)")
+    )
+    .action((channelId: string) =>
+      withClient(async (client) => {
+        const channel = await requireChannel(client, channelId);
+        await client.setChannelMute(channel.id, false);
+        console.log(`Successfully unmuted channel '${channel.name}'`);
+      })
+    );
+
+  channelCmd
+    .command("toggle-mute")
+    .description("Toggle channel mute state")
+    .addArgument(
+      new Argument("<channel-id-or-name>", "ID or name of the channel (case-insensitive)")
+    )
+    .action((channelId: string) =>
+      withClient(async (client) => {
+        const channel = await requireChannel(client, channelId);
+        await client.toggleChannelMute(channel.id);
+        console.log(`Successfully toggled mute for channel '${channel.name}'`);
+      })
+    );
+
+  channelCmd
+    .command("set-mix-volume")
+    .description("Set channel volume in a specific mix")
+    .addArgument(
+      new Argument("<channel-id-or-name>", "ID or name of the channel (case-insensitive)")
+    )
+    .addArgument(new Argument("<mix-id-or-name>", "ID or name of the mix (case-insensitive)"))
+    .addArgument(new Argument("<volume>", "Volume level (0-100)"))
+    .action((channelId: string, mixId: string, volume: string) => {
+      const volumePercent = parsePercent(volume, "Volume");
+      return withClient(async (client) => {
+        const channel = await requireChannel(client, channelId);
+        const mix = await requireMix(client, mixId);
+        await client.setChannelMixVolume(channel.id, mix.id, volumePercent / 100);
+        console.log(
+          `Successfully set channel '${channel.name}' volume to ${volumePercent}% in mix '${mix.name}'`
+        );
+      });
+    });
+
+  channelCmd
+    .command("mute-in-mix")
+    .description("Mute a channel in a specific mix")
+    .addArgument(
+      new Argument("<channel-id-or-name>", "ID or name of the channel (case-insensitive)")
+    )
+    .addArgument(new Argument("<mix-id-or-name>", "ID or name of the mix (case-insensitive)"))
+    .action((channelId: string, mixId: string) =>
+      withClient(async (client) => {
+        const channel = await requireChannel(client, channelId);
+        const mix = await requireMix(client, mixId);
+        await client.setChannelMixMute(channel.id, mix.id, true);
+        console.log(`Successfully muted channel '${channel.name}' in mix '${mix.name}'`);
+      })
+    );
+
+  channelCmd
+    .command("unmute-in-mix")
+    .description("Unmute a channel in a specific mix")
+    .addArgument(
+      new Argument("<channel-id-or-name>", "ID or name of the channel (case-insensitive)")
+    )
+    .addArgument(new Argument("<mix-id-or-name>", "ID or name of the mix (case-insensitive)"))
+    .action((channelId: string, mixId: string) =>
+      withClient(async (client) => {
+        const channel = await requireChannel(client, channelId);
+        const mix = await requireMix(client, mixId);
+        await client.setChannelMixMute(channel.id, mix.id, false);
+        console.log(`Successfully unmuted channel '${channel.name}' in mix '${mix.name}'`);
+      })
+    );
+
+  channelCmd
+    .command("toggle-mute-in-mix")
+    .description("Toggle channel mute state in a specific mix")
+    .addArgument(
+      new Argument("<channel-id-or-name>", "ID or name of the channel (case-insensitive)")
+    )
+    .addArgument(new Argument("<mix-id-or-name>", "ID or name of the mix (case-insensitive)"))
+    .action((channelId: string, mixId: string) =>
+      withClient(async (client) => {
+        const channel = await requireChannel(client, channelId);
+        const mix = await requireMix(client, mixId);
+
+        // Get full channel info to check mix assignment
+        const { channels } = await client.getChannels();
+        const fullChannel = channels.find((c) => c.id === channel.id);
+
+        if (!fullChannel) exitWithError(`Channel '${channelId}' not found`);
+
+        const mixAssignment = fullChannel.mixes?.find((m) => m.id === mix.id);
+
+        if (!mixAssignment) {
+          exitWithError(`Channel '${channel.name}' is not available in mix '${mix.name}'`);
+        }
+
+        const newMuted = !mixAssignment.isMuted;
+        await client.setChannelMixMute(channel.id, mix.id, newMuted);
+        console.log(`Successfully toggled mute for channel '${channel.name}' in mix '${mix.name}'`);
+      })
+    );
+
+  channelCmd
+    .command("isolate")
+    .description("Mute all channels in a mix except for the specified one")
+    .addArgument(
+      new Argument(
+        "<channel-id-or-name>",
+        "ID or name of the channel to isolate (case-insensitive)"
+      )
+    )
+    .addArgument(new Argument("<mix-id-or-name>", "ID or name of the mix (case-insensitive)"))
+    .action((channelId: string, mixId: string) =>
+      withClient(async (client) => {
+        const mix = await requireMix(client, mixId);
+        const targetChannel = await requireChannel(client, channelId);
+        const { channels } = await client.getChannels();
+
+        let mutedCount = 0;
+        let alreadyMutedCount = 0;
+
+        for (const channel of channels) {
+          // Find the channel's assignment for this mix
+          const assignment = channel.mixes?.find((m) => m.id === mix.id);
+
+          // If the channel isn't in this mix (unexpected for Wave Link, but possible in API types), skip
+          if (!assignment) continue;
+
+          if (channel.id === targetChannel.id) {
+            // This is the chosen channel: Unmute it
+            if (assignment.isMuted) {
+              await client.setChannelMixMute(channel.id, mix.id, false);
+              console.log(`Unmuted target channel '${getChannelName(channel)}'`);
+            } else {
+              console.log(`Target channel '${getChannelName(channel)}' is already unmuted`);
+            }
+          } else {
+            // This is NOT the chosen channel: Mute it
+            if (!assignment.isMuted) {
+              await client.setChannelMixMute(channel.id, mix.id, true);
+              mutedCount++;
+            } else {
+              alreadyMutedCount++;
+            }
+          }
+        }
+
+        console.log(
+          `SUCCESS: Isolated '${targetChannel.name}' in mix '${mix.name}'.\n` +
+            `  - Muted ${mutedCount} other channels.\n` +
+            `  - ${alreadyMutedCount} channels were already muted.`
+        );
+      })
+    );
+}

package/src/commands/info.ts

@@ -0,0 +1,19 @@
+import { WaveLinkClient } from "@raphiiko/wavelink-ts";
+import { Command } from "commander";
+import { withClient } from "../services/client.js";
+
+export async function showApplicationInfo(client: WaveLinkClient): Promise<void> {
+  const info = await client.getApplicationInfo();
+  console.log("\n=== Wave Link Application Info ===\n");
+  console.log(`Application ID: ${info.appID}`);
+  console.log(`Name: ${info.name}`);
+  console.log(`Interface Revision: ${info.interfaceRevision}`);
+  console.log();
+}
+
+export function registerInfoCommand(program: Command): void {
+  program
+    .command("info")
+    .description("Show Wave Link application information")
+    .action(() => withClient(showApplicationInfo));
+}

package/src/commands/input.ts

@@ -0,0 +1,128 @@
+import { WaveLinkClient } from "@raphiiko/wavelink-ts";
+import { Argument, Command } from "commander";
+import { withClient } from "../services/client.js";
+import { requireInput } from "../services/finders.js";
+import { formatPercent, formatMuted } from "../utils/format.js";
+import { parsePercent } from "../utils/validation.js";
+
+export async function setInputGain(
+  client: WaveLinkClient,
+  inputId: string,
+  gainPercent: number
+): Promise<void> {
+  const input = await requireInput(client, inputId);
+  await client.setInputGain(input.deviceId, input.inputId, gainPercent / 100);
+  console.log(`Successfully set input '${input.inputName}' gain to ${gainPercent}%`);
+}
+
+export async function setInputMute(
+  client: WaveLinkClient,
+  inputId: string,
+  isMuted: boolean
+): Promise<void> {
+  const input = await requireInput(client, inputId);
+  await client.setInputMute(input.deviceId, input.inputId, isMuted);
+  console.log(`Successfully ${isMuted ? "muted" : "unmuted"} input '${input.inputName}'`);
+}
+
+export async function listInputs(client: WaveLinkClient): Promise<void> {
+  const { inputDevices } = await client.getInputDevices();
+
+  console.log("\n=== Input Devices ===\n");
+
+  if (inputDevices.length === 0) {
+    console.log("No input devices found.");
+    return;
+  }
+
+  for (const device of inputDevices) {
+    console.log(`Device: ${device.name || device.id}`);
+    console.log(`  Device ID: ${device.id}`);
+    console.log(`  Wave Device: ${formatMuted(device.isWaveDevice)}`);
+
+    if (device.inputs.length === 0) {
+      console.log("  No inputs available");
+    } else {
+      for (const input of device.inputs) {
+        console.log(`  Input: ${input.name || input.id}`);
+        console.log(`    Input ID: ${input.id}`);
+        const gainMin = input.gain.min !== undefined ? formatPercent(input.gain.min) : "unknown";
+        const gainMax =
+          input.gain.max !== undefined
+            ? formatPercent(input.gain.max)
+            : input.gain.maxRange !== undefined
+              ? formatPercent(input.gain.maxRange)
+              : "unknown";
+        console.log(
+          `    Gain: ${formatPercent(input.gain.value)} (min: ${gainMin}, max: ${gainMax})`
+        );
+        if (input.isGainLockOn !== undefined) {
+          console.log(`    Gain Lock: ${formatMuted(input.isGainLockOn)}`);
+        }
+        console.log(`    Muted: ${formatMuted(input.isMuted)}`);
+        if (input.micPcMix) {
+          console.log(
+            `    Mic/PC Mix: ${formatPercent(input.micPcMix.value)}${input.micPcMix.isInverted ? " (inverted)" : ""}`
+          );
+        }
+        if (input.effects?.length) {
+          const effectsList = input.effects
+            .map((e) => `${e.name || e.id} (${e.isEnabled ? "ON" : "OFF"})`)
+            .join(", ");
+          console.log(`    Effects: ${effectsList}`);
+        }
+      }
+    }
+    console.log();
+  }
+}
+
+export function registerInputCommands(program: Command): void {
+  const inputCmd = program.command("input").description("Manage input devices");
+
+  inputCmd
+    .command("list")
+    .description("List all input devices with their IDs")
+    .action(() => withClient(listInputs));
+
+  inputCmd
+    .command("set-gain")
+    .description("Set input device gain")
+    .addArgument(
+      new Argument("<input-id-or-name>", "ID or name of the input device (case-insensitive)")
+    )
+    .addArgument(new Argument("<gain>", "Gain level (0-100)"))
+    .action((inputId: string, gain: string) => {
+      const gainPercent = parsePercent(gain, "Gain");
+      return withClient((client) => setInputGain(client, inputId, gainPercent));
+    });
+
+  inputCmd
+    .command("mute")
+    .description("Mute an input device")
+    .addArgument(
+      new Argument("<input-id-or-name>", "ID or name of the input device (case-insensitive)")
+    )
+    .action((inputId: string) => withClient((client) => setInputMute(client, inputId, true)));
+
+  inputCmd
+    .command("unmute")
+    .description("Unmute an input device")
+    .addArgument(
+      new Argument("<input-id-or-name>", "ID or name of the input device (case-insensitive)")
+    )
+    .action((inputId: string) => withClient((client) => setInputMute(client, inputId, false)));
+
+  inputCmd
+    .command("toggle-mute")
+    .description("Toggle input device mute state")
+    .addArgument(
+      new Argument("<input-id-or-name>", "ID or name of the input device (case-insensitive)")
+    )
+    .action((inputId: string) =>
+      withClient(async (client) => {
+        const input = await requireInput(client, inputId);
+        await setInputMute(client, inputId, !input.isMuted);
+      })
+    );
+}

package/src/commands/mix.ts

@@ -0,0 +1,98 @@
+import { WaveLinkClient } from "@raphiiko/wavelink-ts";
+import { Argument, Command } from "commander";
+import { withClient } from "../services/client.js";
+import { requireMix } from "../services/finders.js";
+import { formatPercent, formatMuted } from "../utils/format.js";
+import { parsePercent } from "../utils/validation.js";
+import { setSingleOutputForMix } from "./output.js";
+
+export async function listMixes(client: WaveLinkClient): Promise<void> {
+  const { mixes } = await client.getMixes();
+
+  console.log("\n=== Mixes ===\n");
+
+  if (mixes.length === 0) {
+    console.log("No mixes found.");
+    return;
+  }
+
+  for (const mix of mixes) {
+    console.log(`Mix: ${mix.name}`);
+    console.log(`  ID: ${mix.id}`);
+    console.log(`  Level: ${formatPercent(mix.level)}`);
+    console.log(`  Muted: ${formatMuted(mix.isMuted)}`);
+    console.log();
+  }
+}
+
+export function registerMixCommands(program: Command): void {
+  const mixCmd = program.command("mix").description("Manage mixes");
+
+  mixCmd
+    .command("list")
+    .description("List all mixes with their IDs and names")
+    .action(() => withClient(listMixes));
+
+  mixCmd
+    .command("set-output")
+    .description(
+      "Set a device as the ONLY output for a mix (removes all other outputs from that mix)"
+    )
+    .addArgument(new Argument("<mix-id-or-name>", "ID or name of the mix (case-insensitive)"))
+    .addArgument(
+      new Argument("<output-id-or-name>", "ID or name of the output device (case-insensitive)")
+    )
+    .action((mixId: string, outputId: string) =>
+      withClient((client) => setSingleOutputForMix(client, outputId, mixId))
+    );
+
+  mixCmd
+    .command("set-volume")
+    .description("Set mix master volume")
+    .addArgument(new Argument("<mix-id-or-name>", "ID or name of the mix (case-insensitive)"))
+    .addArgument(new Argument("<volume>", "Volume level (0-100)"))
+    .action((mixId: string, volume: string) => {
+      const volumePercent = parsePercent(volume, "Volume");
+      return withClient(async (client) => {
+        const mix = await requireMix(client, mixId);
+        await client.setMixVolume(mix.id, volumePercent / 100);
+        console.log(`Successfully set mix '${mix.name}' volume to ${volumePercent}%`);
+      });
+    });
+
+  mixCmd
+    .command("mute")
+    .description("Mute a mix")
+    .addArgument(new Argument("<mix-id-or-name>", "ID or name of the mix (case-insensitive)"))
+    .action((mixId: string) =>
+      withClient(async (client) => {
+        const mix = await requireMix(client, mixId);
+        await client.setMixMute(mix.id, true);
+        console.log(`Successfully muted mix '${mix.name}'`);
+      })
+    );
+
+  mixCmd
+    .command("unmute")
+    .description("Unmute a mix")
+    .addArgument(new Argument("<mix-id-or-name>", "ID or name of the mix (case-insensitive)"))
+    .action((mixId: string) =>
+      withClient(async (client) => {
+        const mix = await requireMix(client, mixId);
+        await client.setMixMute(mix.id, false);
+        console.log(`Successfully unmuted mix '${mix.name}'`);
+      })
+    );
+
+  mixCmd
+    .command("toggle-mute")
+    .description("Toggle mix mute state")
+    .addArgument(new Argument("<mix-id-or-name>", "ID or name of the mix (case-insensitive)"))
+    .action((mixId: string) =>
+      withClient(async (client) => {
+        const mix = await requireMix(client, mixId);
+        await client.toggleMixMute(mix.id);
+        console.log(`Successfully toggled mute for mix '${mix.name}'`);
+      })
+    );
+}