@adbjs/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,1384 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+
+// src/commands/auth.ts
+import { AllDebridClient } from "@adbjs/sdk";
+import * as clack from "@clack/prompts";
+import chalk from "chalk";
+import ora from "ora";
+
+// src/config.ts
+import Conf from "conf";
+var Config = class {
+  store;
+  constructor() {
+    this.store = new Conf({
+      projectName: "alldebrid",
+      configName: "config"
+    });
+  }
+  getApiKey() {
+    return process.env.ALLDEBRID_API_KEY || this.store.get("apiKey");
+  }
+  setApiKey(apiKey) {
+    this.store.set("apiKey", apiKey);
+  }
+  clearApiKey() {
+    this.store.delete("apiKey");
+  }
+  hasApiKey() {
+    return !!this.getApiKey();
+  }
+  getConfigPath() {
+    return this.store.path;
+  }
+};
+var config = new Config();
+
+// src/utils/output.ts
+var jsonMode = false;
+function setJsonMode(enabled) {
+  jsonMode = enabled;
+}
+function isJsonMode() {
+  return jsonMode;
+}
+function output(data, formatter) {
+  if (jsonMode) {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    formatter(data);
+  }
+}
+
+// src/commands/auth.ts
+async function authLogin() {
+  clack.intro(chalk.cyan("AllDebrid Authentication"));
+  if (config.hasApiKey()) {
+    const shouldContinue = await clack.confirm({
+      message: "You are already authenticated. Do you want to login again?",
+      initialValue: false
+    });
+    if (clack.isCancel(shouldContinue) || !shouldContinue) {
+      clack.cancel("Authentication cancelled.");
+      process.exit(0);
+    }
+  }
+  const tempClient = new AllDebridClient({
+    apiKey: "",
+    agent: "@adbjs/cli"
+  });
+  let pinData;
+  try {
+    const spinner2 = ora("Generating PIN code...").start();
+    pinData = await tempClient.pin.generate();
+    spinner2.succeed("PIN code generated");
+  } catch (error) {
+    clack.log.error("Failed to generate PIN code");
+    throw error;
+  }
+  if (!pinData) {
+    throw new Error("PIN generation failed");
+  }
+  clack.note(
+    `Visit: ${chalk.blue.underline(pinData.user_url)}
+PIN Code: ${chalk.green.bold(pinData.pin)}
+
+This PIN will expire in 10 minutes`,
+    "Authorization Required"
+  );
+  const spinner = ora("Waiting for authorization...").start();
+  try {
+    const apikey = await tempClient.pin.waitForAuth(pinData.check, pinData.pin, {
+      timeout: 6e5,
+      interval: 3e3
+    });
+    spinner.succeed(chalk.green("Successfully authenticated!"));
+    config.setApiKey(apikey);
+    clack.outro(
+      `Authentication successful!
+API key saved to: ${config.getConfigPath()}`
+    );
+  } catch (error) {
+    spinner.fail("Authentication failed or timed out");
+    throw error;
+  }
+}
+async function authLogout() {
+  if (!config.hasApiKey()) {
+    console.log(chalk.yellow("You are not authenticated"));
+    return;
+  }
+  const shouldLogout = await clack.confirm({
+    message: "Are you sure you want to logout?",
+    initialValue: false
+  });
+  if (clack.isCancel(shouldLogout) || !shouldLogout) {
+    clack.cancel("Logout cancelled.");
+    process.exit(0);
+  }
+  config.clearApiKey();
+  console.log(chalk.green("Successfully logged out"));
+  console.log(chalk.dim(`Config file: ${config.getConfigPath()}`));
+}
+async function authStatus() {
+  const apiKey = config.getApiKey();
+  if (!apiKey) {
+    output({ authenticated: false }, () => {
+      console.log(chalk.yellow("Not authenticated"));
+      console.log(chalk.dim('\nRun "adb auth login" to authenticate'));
+    });
+    return;
+  }
+  try {
+    const client = new AllDebridClient({ apiKey, agent: "@adbjs/cli" });
+    const spinner = isJsonMode() ? null : ora("Verifying API key...").start();
+    const data = await client.user.getInfo();
+    spinner?.succeed("API key is valid");
+    output({ authenticated: true, valid: true, user: data?.user }, () => {
+      console.log(chalk.green("Authenticated"));
+      if (data?.user) {
+        const userInfo2 = data.user;
+        console.log(chalk.dim("\nUser Information:"));
+        console.log(`  Username: ${chalk.cyan(userInfo2.username || "N/A")}`);
+        console.log(
+          `  Premium: ${userInfo2.isPremium ? chalk.green("Yes") : chalk.red("No")}`
+        );
+        if (userInfo2.premiumUntil) {
+          const expiryDate = new Date(userInfo2.premiumUntil * 1e3);
+          console.log(`  Premium Until: ${chalk.cyan(expiryDate.toLocaleDateString())}`);
+        }
+      }
+      console.log(chalk.dim(`
+Config: ${config.getConfigPath()}`));
+    });
+  } catch {
+    output({ authenticated: true, valid: false }, () => {
+      console.log(chalk.red("\nAPI key is invalid or expired"));
+      console.log(chalk.dim('Run "adb auth login" to re-authenticate'));
+    });
+  }
+}
+async function authInteractive() {
+  clack.intro(chalk.cyan("Authentication Menu"));
+  const action = await clack.select({
+    message: "What would you like to do?",
+    options: [
+      { value: "login", label: "Login (Generate new API key)" },
+      { value: "status", label: "Check authentication status" },
+      { value: "logout", label: "Logout (Clear saved API key)" }
+    ]
+  });
+  if (clack.isCancel(action)) {
+    clack.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  switch (action) {
+    case "login":
+      await authLogin();
+      break;
+    case "status":
+      await authStatus();
+      break;
+    case "logout":
+      await authLogout();
+      break;
+  }
+}
+
+// src/commands/host.ts
+import chalk2 from "chalk";
+import ora2 from "ora";
+
+// src/utils/client.ts
+import { AllDebridClient as AllDebridClient2 } from "@adbjs/sdk";
+function createClient(apiKeyOverride) {
+  const apiKey = apiKeyOverride || config.getApiKey();
+  if (!apiKey) {
+    throw new Error(
+      'No API key found. Please run "adb auth login" or set ALLDEBRID_API_KEY environment variable.'
+    );
+  }
+  return new AllDebridClient2({
+    apiKey,
+    agent: "@adbjs/cli"
+  });
+}
+
+// src/commands/host.ts
+async function hostList(hostsOnly) {
+  const client = createClient();
+  const spinner = isJsonMode() ? null : ora2("Fetching supported hosts...").start();
+  try {
+    const hosts = await client.host.list();
+    spinner?.stop();
+    if (!hosts || !hosts.hosts && !hosts.streams && !hosts.redirectors) {
+      output({ hosts: null }, () => console.log(chalk2.yellow("No hosts information available")));
+      return;
+    }
+    output(hosts, () => {
+      if (hostsOnly && hosts.hosts) {
+        console.log(chalk2.green(`
+Supported Hosts (${Object.keys(hosts.hosts).length}):
+`));
+        const sortedHosts = Object.entries(hosts.hosts).sort(([a], [b]) => a.localeCompare(b));
+        for (const [name, _] of sortedHosts) {
+          console.log(`  ${chalk2.cyan(name)}`);
+        }
+        console.log("");
+        return;
+      }
+      if (hosts.hosts) {
+        console.log(chalk2.bold("\nSupported Hosts:"));
+        console.log(chalk2.dim("\u2500".repeat(50)));
+        const sortedHosts = Object.entries(hosts.hosts).sort(([a], [b]) => a.localeCompare(b));
+        for (const [name, info] of sortedHosts) {
+          const typeStr = info.type ? `(${info.type})` : "";
+          console.log(`  ${chalk2.cyan(name)} ${chalk2.dim(typeStr)}`);
+        }
+        console.log("");
+      }
+      if (hosts.streams && Object.keys(hosts.streams).length > 0) {
+        console.log(chalk2.bold("Streaming Hosts:"));
+        console.log(chalk2.dim("\u2500".repeat(50)));
+        const sortedStreams = Object.entries(hosts.streams).sort(([a], [b]) => a.localeCompare(b));
+        for (const [name] of sortedStreams) {
+          console.log(`  ${chalk2.yellow(name)}`);
+        }
+        console.log("");
+      }
+      if (hosts.redirectors && Object.keys(hosts.redirectors).length > 0) {
+        console.log(chalk2.bold(`Supported Redirectors (${Object.keys(hosts.redirectors).length}):`));
+        console.log(chalk2.dim("\u2500".repeat(50)));
+        const sortedRedirectors = Object.keys(hosts.redirectors).sort((a, b) => a.localeCompare(b));
+        for (const redirector of sortedRedirectors) {
+          console.log(`  ${chalk2.magenta(redirector)}`);
+        }
+        console.log("");
+      }
+    });
+  } catch (error) {
+    spinner?.fail("Failed to fetch hosts");
+    console.error(isJsonMode() ? JSON.stringify({ error: error.message }) : chalk2.red(error.message || "Unknown error"));
+    process.exit(1);
+  }
+}
+async function hostDomains() {
+  const client = createClient();
+  const spinner = isJsonMode() ? null : ora2("Fetching all supported domains...").start();
+  try {
+    const result = await client.host.domains();
+    spinner?.stop();
+    const allDomains = [];
+    if (result?.hosts) {
+      allDomains.push(...result.hosts);
+    }
+    if (result?.streams) {
+      allDomains.push(...result.streams);
+    }
+    if (result?.redirectors) {
+      allDomains.push(...result.redirectors);
+    }
+    if (allDomains.length === 0) {
+      output({ domains: [] }, () => console.log(chalk2.yellow("No domains information available")));
+      return;
+    }
+    output(result, () => {
+      console.log(chalk2.green(`
+Supported Domains (${allDomains.length}):
+`));
+      const sortedDomains = allDomains.sort((a, b) => a.localeCompare(b));
+      for (const domain of sortedDomains) {
+        console.log(`  ${chalk2.cyan(domain)}`);
+      }
+      console.log("");
+    });
+  } catch (error) {
+    spinner?.fail("Failed to fetch domains");
+    console.error(isJsonMode() ? JSON.stringify({ error: error.message }) : chalk2.red(error.message || "Unknown error"));
+    process.exit(1);
+  }
+}
+
+// src/commands/link.ts
+import * as clack2 from "@clack/prompts";
+import chalk3 from "chalk";
+import ora3 from "ora";
+async function linkUnlock(url, password2) {
+  const client = createClient();
+  const spinner = isJsonMode() ? null : ora3("Unlocking link...").start();
+  try {
+    const result = await client.link.unlock(url, password2);
+    spinner?.succeed(chalk3.green("Link unlocked successfully!"));
+    output(result, () => {
+      if (result) {
+        console.log(chalk3.dim("\nUnlocked Link Information:"));
+        console.log(`  Filename: ${chalk3.cyan(result.filename || "N/A")}`);
+        console.log(`  Size: ${chalk3.cyan(formatBytes(result.filesize || 0))}`);
+        console.log(`  Host: ${chalk3.cyan(result.host || "N/A")}`);
+        if (result.id) {
+          console.log(`  ID: ${chalk3.cyan(result.id)}`);
+        }
+        console.log(`
+  ${chalk3.blue.underline(result.link || "N/A")}`);
+        if (result.streams && result.streams.length > 0) {
+          console.log(chalk3.dim("\nAvailable Streams:"));
+          for (const stream of result.streams) {
+            console.log(`  ${chalk3.yellow(JSON.stringify(stream))}`);
+          }
+        }
+      }
+    });
+  } catch (error) {
+    spinner?.fail("Failed to unlock link");
+    console.error(isJsonMode() ? JSON.stringify({ error: error.message }) : chalk3.red(error.message || "Unknown error"));
+    process.exit(1);
+  }
+}
+async function linkInfo(url, password2) {
+  const client = createClient();
+  const spinner = isJsonMode() ? null : ora3("Fetching link information...").start();
+  try {
+    const data = await client.link.infos(url, password2);
+    spinner?.stop();
+    if (!data?.infos || data.infos.length === 0) {
+      output({ infos: [] }, () => console.log(chalk3.yellow("No link information available")));
+      return;
+    }
+    output(data, () => {
+      for (const info of data.infos) {
+        console.log(chalk3.bold("\nLink Information:"));
+        console.log(chalk3.dim("\u2500".repeat(50)));
+        console.log(`Filename: ${chalk3.cyan(info.filename || "N/A")}`);
+        console.log(`Size: ${chalk3.cyan(formatBytes(info.size || 0))}`);
+        console.log(`Host: ${chalk3.cyan(info.host || "N/A")}`);
+        if (info.hostDomain) {
+          console.log(`Host Domain: ${chalk3.cyan(info.hostDomain)}`);
+        }
+        if (info.link) {
+          console.log(`Link: ${chalk3.blue.underline(info.link)}`);
+        }
+        console.log("");
+      }
+    });
+  } catch (error) {
+    spinner?.fail("Failed to fetch link information");
+    console.error(isJsonMode() ? JSON.stringify({ error: error.message }) : chalk3.red(error.message || "Unknown error"));
+    process.exit(1);
+  }
+}
+async function linkStream(id, stream) {
+  const client = createClient();
+  const spinner = isJsonMode() ? null : ora3("Fetching streaming link...").start();
+  try {
+    const result = await client.link.streaming(id, stream);
+    spinner?.succeed(chalk3.green("Streaming link retrieved!"));
+    output(result, () => {
+      if (result) {
+        console.log(chalk3.dim("\nStreaming Information:"));
+        console.log(`  Filename: ${chalk3.cyan(result.filename || "N/A")}`);
+        console.log(`  Size: ${chalk3.cyan(formatBytes(result.filesize || 0))}`);
+        if (result.delayed) {
+          console.log(chalk3.yellow(`
+  \u23F1  Delayed by ${result.delayed} seconds`));
+        }
+        console.log(`
+  ${chalk3.blue.underline(result.link || "N/A")}`);
+      }
+    });
+  } catch (error) {
+    spinner?.fail("Failed to fetch streaming link");
+    console.error(isJsonMode() ? JSON.stringify({ error: error.message }) : chalk3.red(error.message || "Unknown error"));
+    process.exit(1);
+  }
+}
+async function linkRedirector(url) {
+  const client = createClient();
+  const spinner = isJsonMode() ? null : ora3("Extracting links from redirector...").start();
+  try {
+    const data = await client.link.redirector(url);
+    spinner?.stop();
+    if (!data?.links || data.links.length === 0) {
+      output({ links: [] }, () => console.log(chalk3.yellow("No links found")));
+      return;
+    }
+    output(data, () => {
+      console.log(chalk3.green(`
+Found ${data.links.length} link(s):
+`));
+      for (const link2 of data.links) {
+        console.log(`  ${chalk3.blue.underline(link2)}`);
+      }
+      console.log("");
+    });
+  } catch (error) {
+    spinner?.fail("Failed to extract links from redirector");
+    console.error(isJsonMode() ? JSON.stringify({ error: error.message }) : chalk3.red(error.message || "Unknown error"));
+    process.exit(1);
+  }
+}
+async function linkInteractive() {
+  clack2.intro(chalk3.cyan("Link Management"));
+  const action = await clack2.select({
+    message: "What would you like to do?",
+    options: [
+      { value: "unlock", label: "Unlock premium link" },
+      { value: "info", label: "Get link information" },
+      { value: "stream", label: "Get streaming link" },
+      { value: "redirector", label: "Extract from redirector" }
+    ]
+  });
+  if (clack2.isCancel(action)) {
+    clack2.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  switch (action) {
+    case "unlock": {
+      const url = await clack2.text({
+        message: "Enter link to unlock:",
+        validate: (value) => {
+          if (!value)
+            return "Please enter a link";
+          return void 0;
+        }
+      });
+      if (clack2.isCancel(url)) {
+        clack2.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      const needsPassword = await clack2.confirm({
+        message: "Does this link require a password?",
+        initialValue: false
+      });
+      let password2;
+      if (!clack2.isCancel(needsPassword) && needsPassword) {
+        const passwordInput = await clack2.password({
+          message: "Enter password:"
+        });
+        if (clack2.isCancel(passwordInput)) {
+          clack2.cancel("Operation cancelled.");
+          process.exit(0);
+        }
+        password2 = passwordInput;
+      }
+      await linkUnlock(url, password2);
+      break;
+    }
+    case "info": {
+      const url = await clack2.text({
+        message: "Enter link URL:",
+        validate: (value) => {
+          if (!value)
+            return "Please enter a link";
+          return void 0;
+        }
+      });
+      if (clack2.isCancel(url)) {
+        clack2.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      await linkInfo(url);
+      break;
+    }
+    case "stream": {
+      const id = await clack2.text({
+        message: "Enter link ID:",
+        validate: (value) => {
+          if (!value)
+            return "Please enter a link ID";
+          return void 0;
+        }
+      });
+      if (clack2.isCancel(id)) {
+        clack2.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      const stream = await clack2.text({
+        message: 'Enter stream quality (e.g., "original", "1080p"):',
+        validate: (value) => {
+          if (!value)
+            return "Please enter a stream quality";
+          return void 0;
+        }
+      });
+      if (clack2.isCancel(stream)) {
+        clack2.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      await linkStream(id, stream);
+      break;
+    }
+    case "redirector": {
+      const url = await clack2.text({
+        message: "Enter redirector URL:",
+        validate: (value) => {
+          if (!value)
+            return "Please enter a redirector URL";
+          return void 0;
+        }
+      });
+      if (clack2.isCancel(url)) {
+        clack2.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      await linkRedirector(url);
+      break;
+    }
+  }
+}
+function formatBytes(bytes) {
+  if (bytes === 0)
+    return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${Number.parseFloat((bytes / k ** i).toFixed(2))} ${sizes[i]}`;
+}
+
+// src/commands/magnet.ts
+import { readFileSync } from "fs";
+import * as clack3 from "@clack/prompts";
+import chalk4 from "chalk";
+import ora4 from "ora";
+async function magnetUpload(magnetOrFile) {
+  const client = createClient();
+  const spinner = isJsonMode() ? null : ora4("Uploading magnet/torrent...").start();
+  try {
+    let result;
+    if (magnetOrFile.startsWith("magnet:")) {
+      result = await client.magnet.upload(magnetOrFile);
+    } else {
+      try {
+        const fileBuffer = readFileSync(magnetOrFile);
+        const file = new File([fileBuffer], magnetOrFile.split(/[\\/]/).pop() || "torrent.torrent");
+        result = await client.magnet.uploadFile(file);
+      } catch {
+        result = await client.magnet.upload(magnetOrFile);
+      }
+    }
+    spinner?.succeed(chalk4.green("Magnet uploaded successfully!"));
+    if (result) {
+      const items = "magnets" in result ? result.magnets : "files" in result ? result.files : void 0;
+      if (items && items.length > 0) {
+        const item = items[0];
+        output(item, () => {
+          console.log(chalk4.dim("\nMagnet Information:"));
+          console.log(`  ID: ${chalk4.cyan(item.id)}`);
+          console.log(`  Name: ${chalk4.cyan(item.name)}`);
+          console.log(`  Hash: ${chalk4.cyan(item.hash)}`);
+          console.log(`  Size: ${chalk4.cyan(formatBytes2(item.size || 0))}`);
+          console.log(`  Ready: ${item.ready ? chalk4.green("Yes") : chalk4.yellow("Processing")}`);
+        });
+      }
+    }
+  } catch (error) {
+    spinner?.fail("Failed to upload magnet");
+    console.error(isJsonMode() ? JSON.stringify({ error: error.message }) : chalk4.red(error.message || "Unknown error"));
+    process.exit(1);
+  }
+}
+async function magnetList(statusFilter) {
+  const client = createClient();
+  const spinner = isJsonMode() ? null : ora4("Fetching magnets...").start();
+  try {
+    const result = await client.magnet.statusList(
+      statusFilter
+    );
+    spinner?.stop();
+    if (!result?.magnets || result.magnets.length === 0) {
+      output({ magnets: [] }, () => console.log(chalk4.yellow("No magnets found")));
+      return;
+    }
+    output(result, () => {
+      console.log(chalk4.green(`
+Found ${result.magnets.length} magnet(s):
+`));
+      for (const magnet2 of result.magnets) {
+        const statusColor = getStatusColor(magnet2.status || "");
+        console.log(`${chalk4.bold(`#${magnet2.id}`)} - ${magnet2.filename}`);
+        console.log(`  Status: ${statusColor(magnet2.status)}`);
+        console.log(`  Size: ${formatBytes2(magnet2.size || 0)}`);
+        if (magnet2.status === "Downloading" && magnet2.downloaded !== void 0 && magnet2.size) {
+          const progress = Math.round(magnet2.downloaded / magnet2.size * 100);
+          console.log(
+            `  Progress: ${chalk4.cyan(`${progress}%`)} (${formatBytes2(magnet2.downloaded)} / ${formatBytes2(magnet2.size)})`
+          );
+          if (magnet2.downloadSpeed) {
+            console.log(`  Speed: ${chalk4.cyan(`${formatBytes2(magnet2.downloadSpeed)}/s`)}`);
+          }
+        }
+        console.log("");
+      }
+    });
+  } catch (error) {
+    spinner?.fail("Failed to fetch magnets");
+    console.error(isJsonMode() ? JSON.stringify({ error: error.message }) : chalk4.red(error.message || "Unknown error"));
+    process.exit(1);
+  }
+}
+async function magnetStatus(id, options) {
+  const client = createClient();
+  if (options?.live && !id) {
+    const session = options.session ?? Math.floor(Math.random() * 1e6);
+    const counter = options.counter ?? 0;
+    const spinner2 = isJsonMode() ? null : ora4("Fetching magnet status (live mode)...").start();
+    try {
+      const result = await client.magnet.statusLive({ session, counter });
+      spinner2?.stop();
+      if (!result?.magnets || result.magnets.length === 0) {
+        output({ magnets: [], session, counter: result?.counter ?? counter }, () => {
+          console.log(chalk4.yellow("No magnets found"));
+          console.log(chalk4.dim(`
+Session: ${session} | Counter: ${result?.counter ?? counter}`));
+        });
+        return;
+      }
+      output({ ...result, session }, () => {
+        console.log(
+          chalk4.green(
+            `
+Found ${result.magnets.length} magnet(s)${result.fullsync ? " (full sync)" : " (delta)"}:
+`
+          )
+        );
+        for (const magnet2 of result.magnets) {
+          const statusColor = getStatusColor(magnet2.status || "");
+          console.log(`${chalk4.bold(`#${magnet2.id}`)} - ${magnet2.filename}`);
+          console.log(`  Status: ${statusColor(magnet2.status)}`);
+          console.log(`  Size: ${formatBytes2(magnet2.size || 0)}`);
+          if (magnet2.status === "Downloading" && magnet2.downloaded !== void 0 && magnet2.size) {
+            const progress = Math.round(magnet2.downloaded / magnet2.size * 100);
+            const progressStr = `${formatBytes2(magnet2.downloaded)} / ${formatBytes2(magnet2.size)}`;
+            console.log(`  Progress: ${chalk4.cyan(`${progress}%`)} (${progressStr})`);
+            if (magnet2.downloadSpeed) {
+              console.log(`  Speed: ${chalk4.cyan(`${formatBytes2(magnet2.downloadSpeed)}/s`)}`);
+            }
+          }
+          console.log("");
+        }
+        console.log(chalk4.dim(`Session: ${session} | Counter: ${result.counter ?? counter}`));
+        console.log(
+          chalk4.dim(
+            `Use these values for next call: --session ${session} --counter ${result.counter ?? counter}`
+          )
+        );
+      });
+    } catch (error) {
+      spinner2?.fail("Failed to fetch magnet status");
+      console.error(isJsonMode() ? JSON.stringify({ error: error.message }) : chalk4.red(error.message || "Unknown error"));
+      process.exit(1);
+    }
+    return;
+  }
+  if (!id) {
+    const msg = "Error: Magnet ID required for standard mode";
+    console.error(isJsonMode() ? JSON.stringify({ error: msg }) : chalk4.red(msg));
+    if (!isJsonMode()) {
+      console.log(chalk4.dim("Usage: adb magnet status <id>"));
+      console.log(chalk4.dim("   or: adb magnet status --live [--session <n>] [--counter <n>]"));
+    }
+    process.exit(1);
+  }
+  const spinner = isJsonMode() ? null : ora4("Fetching magnet status...").start();
+  try {
+    const result = await client.magnet.status(Number.parseInt(id));
+    spinner?.stop();
+    if (!result?.magnets || result.magnets.length === 0) {
+      output({ magnet: null }, () => console.log(chalk4.yellow("Magnet not found")));
+      return;
+    }
+    const magnet2 = result.magnets[0];
+    output(magnet2, () => {
+      console.log(chalk4.bold(`
+Magnet #${magnet2?.id}`));
+      console.log(chalk4.dim("\u2500".repeat(50)));
+      console.log(`Filename: ${chalk4.cyan(magnet2?.filename || "N/A")}`);
+      console.log(`Status: ${getStatusColor(magnet2?.status || "")(magnet2?.status)}`);
+      console.log(`Size: ${chalk4.cyan(formatBytes2(magnet2?.size || 0))}`);
+      if (magnet2?.status === "Downloading" && magnet2.downloaded !== void 0 && magnet2.size) {
+        const progress = Math.round(magnet2.downloaded / magnet2.size * 100);
+        console.log(
+          `Progress: ${chalk4.cyan(`${progress}%`)} (${formatBytes2(magnet2.downloaded)} / ${formatBytes2(magnet2.size)})`
+        );
+        if (magnet2.downloadSpeed) {
+          console.log(`Speed: ${chalk4.cyan(`${formatBytes2(magnet2.downloadSpeed)}/s`)}`);
+        }
+      }
+      console.log("");
+    });
+  } catch (error) {
+    spinner?.fail("Failed to fetch magnet status");
+    console.error(isJsonMode() ? JSON.stringify({ error: error.message }) : chalk4.red(error.message || "Unknown error"));
+    process.exit(1);
+  }
+}
+async function magnetWatch(id) {
+  const client = createClient();
+  const magnetId = Number.parseInt(id);
+  console.log(chalk4.cyan(`Monitoring magnet #${id}...
+`));
+  try {
+    await client.magnet.watch(magnetId, {
+      interval: 2e3,
+      maxAttempts: 0,
+      stopOnStatus: "",
+      // Empty string won't match any real status
+      onUpdate: (status) => {
+        if (!status?.magnets || !Array.isArray(status.magnets)) {
+          return;
+        }
+        const magnet2 = status.magnets[0];
+        if (!magnet2) {
+          return;
+        }
+        process.stdout.write("\r\x1B[K");
+        const currentStatus = magnet2.status || magnet2.statusCode?.toString() || "Processing";
+        const statusStr = getStatusColor(currentStatus)(currentStatus);
+        let progress = 0;
+        if (magnet2.status === "Ready" || magnet2.statusCode === 4) {
+          progress = 100;
+        } else if (magnet2.downloaded !== void 0 && magnet2.size) {
+          progress = Math.round(magnet2.downloaded / magnet2.size * 100);
+        }
+        const speed = magnet2.downloadSpeed ? `${formatBytes2(magnet2.downloadSpeed)}/s` : "N/A";
+        process.stdout.write(
+          `Status: ${statusStr} | Progress: ${chalk4.cyan(`${progress}%`)} | Speed: ${chalk4.cyan(speed)}`
+        );
+        if (magnet2.status === "Ready" || magnet2.statusCode === 4) {
+          console.log(chalk4.green("\n\nDownload complete!"));
+          process.exit(0);
+        } else if (magnet2.status === "Error") {
+          console.log(chalk4.red("\n\nDownload failed!"));
+          process.exit(1);
+        }
+      }
+    });
+  } catch (error) {
+    console.error(chalk4.red(`
+
+Error: ${error.message || "Unknown error"}`));
+    process.exit(1);
+  }
+}
+async function magnetDelete(id) {
+  const client = createClient();
+  if (!isJsonMode()) {
+    const shouldDelete = await clack3.confirm({
+      message: `Delete magnet #${id}?`,
+      initialValue: false
+    });
+    if (clack3.isCancel(shouldDelete) || !shouldDelete) {
+      clack3.cancel("Deletion cancelled.");
+      return;
+    }
+  }
+  const spinner = isJsonMode() ? null : ora4("Deleting magnet...").start();
+  try {
+    await client.magnet.delete(Number.parseInt(id));
+    output({ success: true, id: Number.parseInt(id) }, () => {
+      spinner?.succeed(chalk4.green(`Magnet #${id} deleted successfully`));
+    });
+  } catch (error) {
+    spinner?.fail("Failed to delete magnet");
+    console.error(isJsonMode() ? JSON.stringify({ error: error.message }) : chalk4.red(error.message || "Unknown error"));
+    process.exit(1);
+  }
+}
+async function magnetRestart(id) {
+  const client = createClient();
+  const spinner = isJsonMode() ? null : ora4("Restarting magnet...").start();
+  try {
+    await client.magnet.restart(Number.parseInt(id));
+    output({ success: true, id: Number.parseInt(id) }, () => {
+      spinner?.succeed(chalk4.green(`Magnet #${id} restarted successfully`));
+    });
+  } catch (error) {
+    spinner?.fail("Failed to restart magnet");
+    console.error(isJsonMode() ? JSON.stringify({ error: error.message }) : chalk4.red(error.message || "Unknown error"));
+    process.exit(1);
+  }
+}
+async function magnetFiles(id) {
+  const client = createClient();
+  const spinner = isJsonMode() ? null : ora4("Fetching download links...").start();
+  try {
+    const data = await client.magnet.files(Number.parseInt(id));
+    spinner?.stop();
+    if (!data?.magnets || data.magnets.length === 0) {
+      output({ files: [] }, () => console.log(chalk4.yellow("No files available yet")));
+      return;
+    }
+    output(data, () => {
+      console.log(chalk4.green(`
+Download Links:
+`));
+      for (const magnet2 of data.magnets) {
+        if (magnet2.files && magnet2.files.length > 0) {
+          extractFiles(magnet2.files, 0);
+        }
+      }
+    });
+  } catch (error) {
+    spinner?.fail("Failed to fetch files");
+    console.error(isJsonMode() ? JSON.stringify({ error: error.message }) : chalk4.red(error.message || "Unknown error"));
+    process.exit(1);
+  }
+}
+function extractFiles(files, level) {
+  for (const file of files) {
+    const indent = "  ".repeat(level);
+    if (file.l && file.l.length > 0) {
+      console.log(`${indent}${chalk4.bold(file.n)}`);
+      file.l.forEach((link2) => {
+        console.log(`${indent}  ${chalk4.blue.underline(link2)}`);
+      });
+    }
+    if (file.e && file.e.length > 0) {
+      console.log(`${indent}${chalk4.dim(`${file.n}/`)}`);
+      extractFiles(file.e, level + 1);
+    }
+  }
+}
+async function magnetInteractive() {
+  clack3.intro(chalk4.cyan("Magnet Management"));
+  const action = await clack3.select({
+    message: "What would you like to do?",
+    options: [
+      { value: "list", label: "List all magnets" },
+      { value: "upload", label: "Upload new magnet/torrent" },
+      { value: "status", label: "Check magnet status" },
+      { value: "watch", label: "Monitor magnet progress" },
+      { value: "files", label: "Get download links" },
+      { value: "delete", label: "Delete magnet" },
+      { value: "restart", label: "Restart failed magnet" }
+    ]
+  });
+  if (clack3.isCancel(action)) {
+    clack3.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  switch (action) {
+    case "list":
+      await magnetList();
+      break;
+    case "upload": {
+      const magnet2 = await clack3.text({
+        message: "Enter magnet link or torrent file path:",
+        validate: (value) => {
+          if (!value)
+            return "Please enter a magnet link or file path";
+          return void 0;
+        }
+      });
+      if (clack3.isCancel(magnet2)) {
+        clack3.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      await magnetUpload(magnet2);
+      break;
+    }
+    case "status":
+    case "watch":
+    case "files":
+    case "delete":
+    case "restart": {
+      const id = await clack3.text({
+        message: "Enter magnet ID:",
+        validate: (value) => {
+          if (!value || Number.isNaN(Number.parseInt(value))) {
+            return "Please enter a valid magnet ID";
+          }
+          return void 0;
+        }
+      });
+      if (clack3.isCancel(id)) {
+        clack3.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      if (action === "status")
+        await magnetStatus(id);
+      else if (action === "watch")
+        await magnetWatch(id);
+      else if (action === "files")
+        await magnetFiles(id);
+      else if (action === "delete")
+        await magnetDelete(id);
+      else if (action === "restart")
+        await magnetRestart(id);
+      break;
+    }
+  }
+}
+function formatBytes2(bytes) {
+  if (bytes === 0)
+    return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${Number.parseFloat((bytes / k ** i).toFixed(2))} ${sizes[i]}`;
+}
+function getStatusColor(status) {
+  switch (status) {
+    case "Ready":
+      return chalk4.green;
+    case "Downloading":
+      return chalk4.blue;
+    case "Error":
+      return chalk4.red;
+    case "Expired":
+      return chalk4.gray;
+    default:
+      return chalk4.yellow;
+  }
+}
+
+// src/commands/user.ts
+import * as clack4 from "@clack/prompts";
+import chalk5 from "chalk";
+import ora5 from "ora";
+async function userInfo() {
+  const client = createClient();
+  const spinner = isJsonMode() ? null : ora5("Fetching user information...").start();
+  try {
+    const data = await client.user.getInfo();
+    spinner?.stop();
+    output(data, () => {
+      if (data?.user) {
+        const userInfo2 = data.user;
+        console.log(chalk5.bold("\nUser Information:"));
+        console.log(chalk5.dim("\u2500".repeat(50)));
+        console.log(`Username: ${chalk5.cyan(userInfo2.username || "N/A")}`);
+        console.log(`Email: ${chalk5.cyan(userInfo2.email || "N/A")}`);
+        console.log(`Premium: ${userInfo2.isPremium ? chalk5.green("Yes") : chalk5.yellow("No")}`);
+        if (userInfo2.premiumUntil) {
+          const expiryDate = new Date(userInfo2.premiumUntil * 1e3);
+          console.log(`Premium Until: ${chalk5.cyan(expiryDate.toLocaleDateString())}`);
+        }
+        if (userInfo2.remainingTrialQuota !== void 0) {
+          console.log(`Remaining Trial Quota: ${chalk5.cyan(formatBytes3(userInfo2.remainingTrialQuota))}`);
+        }
+        if (userInfo2.fidelityPoints !== void 0) {
+          console.log(`Fidelity Points: ${chalk5.cyan(userInfo2.fidelityPoints)}`);
+        }
+        console.log("");
+      }
+    });
+  } catch (error) {
+    spinner?.fail("Failed to fetch user information");
+    console.error(isJsonMode() ? JSON.stringify({ error: error.message }) : chalk5.red(error.message || "Unknown error"));
+    process.exit(1);
+  }
+}
+async function userSavedList() {
+  const client = createClient();
+  const spinner = isJsonMode() ? null : ora5("Fetching saved links...").start();
+  try {
+    const result = await client.user.getLinks();
+    spinner?.stop();
+    if (!result?.links || result.links.length === 0) {
+      output({ links: [] }, () => console.log(chalk5.yellow("No saved links found")));
+      return;
+    }
+    output(result, () => {
+      console.log(chalk5.green(`
+Found ${result.links.length} saved link(s):
+`));
+      for (const link2 of result.links) {
+        console.log(`${chalk5.bold(link2.filename || "N/A")}`);
+        console.log(`  Link: ${chalk5.blue.underline(link2.link || "N/A")}`);
+        console.log(`  Size: ${chalk5.cyan(formatBytes3(link2.size || 0))}`);
+        console.log(`  Host: ${chalk5.cyan(link2.host || "N/A")}`);
+        if (link2.date) {
+          const date = new Date(link2.date * 1e3);
+          console.log(`  Date: ${chalk5.dim(date.toLocaleString())}`);
+        }
+        console.log("");
+      }
+    });
+  } catch (error) {
+    spinner?.fail("Failed to fetch saved links");
+    console.error(isJsonMode() ? JSON.stringify({ error: error.message }) : chalk5.red(error.message || "Unknown error"));
+    process.exit(1);
+  }
+}
+async function userSavedAdd(urls) {
+  const client = createClient();
+  const spinner = isJsonMode() ? null : ora5("Saving link(s)...").start();
+  try {
+    await client.user.saveLink(urls);
+    const count = Array.isArray(urls) ? urls.length : 1;
+    output({ success: true, count }, () => {
+      spinner?.succeed(chalk5.green(`${count} link(s) saved successfully!`));
+    });
+  } catch (error) {
+    spinner?.fail("Failed to save link(s)");
+    console.error(isJsonMode() ? JSON.stringify({ error: error.message }) : chalk5.red(error.message || "Unknown error"));
+    process.exit(1);
+  }
+}
+async function userSavedDelete(links) {
+  const client = createClient();
+  if (!isJsonMode()) {
+    const shouldDelete = await clack4.confirm({
+      message: `Delete ${Array.isArray(links) ? links.length : 1} saved link(s)?`,
+      initialValue: false
+    });
+    if (clack4.isCancel(shouldDelete) || !shouldDelete) {
+      clack4.cancel("Deletion cancelled.");
+      return;
+    }
+  }
+  const spinner = isJsonMode() ? null : ora5("Deleting saved link(s)...").start();
+  try {
+    await client.user.deleteLink(links);
+    const count = Array.isArray(links) ? links.length : 1;
+    output({ success: true, count }, () => {
+      spinner?.succeed(chalk5.green(`${count} saved link(s) deleted successfully`));
+    });
+  } catch (error) {
+    spinner?.fail("Failed to delete saved link(s)");
+    console.error(isJsonMode() ? JSON.stringify({ error: error.message }) : chalk5.red(error.message || "Unknown error"));
+    process.exit(1);
+  }
+}
+async function userHistory() {
+  const client = createClient();
+  const spinner = isJsonMode() ? null : ora5("Fetching download history...").start();
+  try {
+    const result = await client.user.getHistory();
+    spinner?.stop();
+    if (!result?.links || result.links.length === 0) {
+      output({ links: [] }, () => console.log(chalk5.yellow("No download history found")));
+      return;
+    }
+    output(result, () => {
+      console.log(chalk5.green(`
+Download History (${result.links.length} item(s)):
+`));
+      for (const item of result.links) {
+        console.log(`${chalk5.bold(item.filename || "N/A")}`);
+        console.log(`  Link: ${chalk5.blue.underline(item.link || "N/A")}`);
+        if (item.date) {
+          const date = new Date(item.date * 1e3);
+          console.log(`  Date: ${chalk5.dim(date.toLocaleString())}`);
+        }
+        console.log("");
+      }
+    });
+  } catch (error) {
+    spinner?.fail("Failed to fetch download history");
+    console.error(isJsonMode() ? JSON.stringify({ error: error.message }) : chalk5.red(error.message || "Unknown error"));
+    process.exit(1);
+  }
+}
+async function userHistoryClear() {
+  const client = createClient();
+  if (!isJsonMode()) {
+    const shouldClear = await clack4.confirm({
+      message: "Clear your entire download history?",
+      initialValue: false
+    });
+    if (clack4.isCancel(shouldClear) || !shouldClear) {
+      clack4.cancel("Operation cancelled.");
+      return;
+    }
+  }
+  const spinner = isJsonMode() ? null : ora5("Clearing download history...").start();
+  try {
+    await client.user.clearHistory();
+    output({ success: true }, () => {
+      spinner?.succeed(chalk5.green("Download history cleared successfully"));
+    });
+  } catch (error) {
+    spinner?.fail("Failed to clear download history");
+    console.error(isJsonMode() ? JSON.stringify({ error: error.message }) : chalk5.red(error.message || "Unknown error"));
+    process.exit(1);
+  }
+}
+async function userInteractive() {
+  clack4.intro(chalk5.cyan("User Management"));
+  const action = await clack4.select({
+    message: "What would you like to do?",
+    options: [
+      { value: "info", label: "View account information" },
+      { value: "saved-list", label: "List saved links" },
+      { value: "saved-add", label: "Save new link" },
+      { value: "saved-delete", label: "Delete saved link" },
+      { value: "history", label: "View download history" },
+      { value: "history-clear", label: "Clear download history" }
+    ]
+  });
+  if (clack4.isCancel(action)) {
+    clack4.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  switch (action) {
+    case "info":
+      await userInfo();
+      break;
+    case "saved-list":
+      await userSavedList();
+      break;
+    case "saved-add": {
+      const link2 = await clack4.text({
+        message: "Enter link to save:",
+        validate: (value) => {
+          if (!value)
+            return "Please enter a link";
+          return void 0;
+        }
+      });
+      if (clack4.isCancel(link2)) {
+        clack4.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      await userSavedAdd(link2);
+      break;
+    }
+    case "saved-delete": {
+      const link2 = await clack4.text({
+        message: "Enter link to delete:",
+        validate: (value) => {
+          if (!value)
+            return "Please enter a link";
+          return void 0;
+        }
+      });
+      if (clack4.isCancel(link2)) {
+        clack4.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      await userSavedDelete(link2);
+      break;
+    }
+    case "history":
+      await userHistory();
+      break;
+    case "history-clear":
+      await userHistoryClear();
+      break;
+  }
+}
+function formatBytes3(bytes) {
+  if (bytes === 0)
+    return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${Number.parseFloat((bytes / k ** i).toFixed(2))} ${sizes[i]}`;
+}
+
+// src/commands/voucher.ts
+import * as clack5 from "@clack/prompts";
+import chalk6 from "chalk";
+import ora6 from "ora";
+async function voucherBalance() {
+  const client = createClient();
+  const spinner = isJsonMode() ? null : ora6("Fetching voucher balance...").start();
+  try {
+    const balance = await client.voucher.getBalance();
+    spinner?.stop();
+    output(balance, () => {
+      console.log(chalk6.bold("\nVoucher Balance:"));
+      console.log(chalk6.dim("\u2500".repeat(50)));
+      if (balance?.balance !== void 0) {
+        console.log(`Balance: ${chalk6.cyan(balance.balance)}`);
+      }
+      console.log("");
+    });
+  } catch (error) {
+    spinner?.fail("Failed to fetch voucher balance");
+    console.error(isJsonMode() ? JSON.stringify({ error: error.message }) : chalk6.red(error.message || "Unknown error"));
+    process.exit(1);
+  }
+}
+async function voucherList(quantity) {
+  const client = createClient();
+  const spinner = isJsonMode() ? null : ora6("Fetching vouchers...").start();
+  try {
+    const result = await client.voucher.getVouchers(quantity);
+    spinner?.stop();
+    if (!result?.codes || result.codes.length === 0) {
+      output({ codes: [] }, () => console.log(chalk6.yellow("No vouchers found")));
+      return;
+    }
+    output(result, () => {
+      console.log(chalk6.green(`
+Vouchers (${result.codes.length}):
+`));
+      for (const code of result.codes) {
+        console.log(`  ${chalk6.cyan(code)}`);
+      }
+      if (result.partialList) {
+        console.log(chalk6.yellow("\n(Partial list - not all vouchers available)"));
+      }
+      console.log("");
+    });
+  } catch (error) {
+    spinner?.fail("Failed to fetch vouchers");
+    console.error(isJsonMode() ? JSON.stringify({ error: error.message }) : chalk6.red(error.message || "Unknown error"));
+    process.exit(1);
+  }
+}
+async function voucherGenerate(quantity, days) {
+  const client = createClient();
+  if (!isJsonMode()) {
+    const shouldGenerate = await clack5.confirm({
+      message: `Generate ${quantity} voucher(s) for ${days} days?`,
+      initialValue: false
+    });
+    if (clack5.isCancel(shouldGenerate) || !shouldGenerate) {
+      clack5.cancel("Operation cancelled.");
+      return;
+    }
+  }
+  const spinner = isJsonMode() ? null : ora6("Generating voucher(s)...").start();
+  try {
+    const result = await client.voucher.generateVouchers(quantity, days);
+    spinner?.succeed(chalk6.green(`${quantity} voucher(s) generated successfully!`));
+    output(result, () => {
+      if (result?.codes && result.codes.length > 0) {
+        console.log(chalk6.bold("\nGenerated Voucher Codes:\n"));
+        for (const code of result.codes) {
+          console.log(`  ${chalk6.cyan(code)}`);
+        }
+        if (result.pricePerVoucher !== void 0) {
+          console.log(chalk6.dim(`
+Price per voucher: $${result.pricePerVoucher}`));
+        }
+        console.log("");
+      }
+    });
+  } catch (error) {
+    spinner?.fail("Failed to generate voucher(s)");
+    console.error(isJsonMode() ? JSON.stringify({ error: error.message }) : chalk6.red(error.message || "Unknown error"));
+    process.exit(1);
+  }
+}
+async function voucherInteractive() {
+  clack5.intro(chalk6.cyan("Voucher Management (Reseller)"));
+  const action = await clack5.select({
+    message: "What would you like to do?",
+    options: [
+      { value: "balance", label: "Check balance" },
+      { value: "list", label: "List vouchers" },
+      { value: "generate", label: "Generate vouchers" }
+    ]
+  });
+  if (clack5.isCancel(action)) {
+    clack5.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  switch (action) {
+    case "balance":
+      await voucherBalance();
+      break;
+    case "list": {
+      const quantityInput = await clack5.text({
+        message: "How many vouchers to list? (optional)",
+        validate: (value) => {
+          if (value && Number.isNaN(Number.parseInt(value))) {
+            return "Please enter a valid number";
+          }
+          return void 0;
+        }
+      });
+      if (clack5.isCancel(quantityInput)) {
+        clack5.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      const quantity = quantityInput ? Number.parseInt(quantityInput) : void 0;
+      await voucherList(quantity);
+      break;
+    }
+    case "generate": {
+      const quantityInput = await clack5.text({
+        message: "How many vouchers to generate?",
+        validate: (value) => {
+          const num = Number.parseInt(value);
+          if (Number.isNaN(num) || num <= 0) {
+            return "Please enter a valid positive number";
+          }
+          return void 0;
+        }
+      });
+      if (clack5.isCancel(quantityInput)) {
+        clack5.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      const daysInput = await clack5.text({
+        message: "Duration in days?",
+        validate: (value) => {
+          const num = Number.parseInt(value);
+          if (Number.isNaN(num) || num <= 0) {
+            return "Please enter a valid positive number";
+          }
+          return void 0;
+        }
+      });
+      if (clack5.isCancel(daysInput)) {
+        clack5.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      await voucherGenerate(Number.parseInt(quantityInput), Number.parseInt(daysInput));
+      break;
+    }
+  }
+}
+
+// src/index.ts
+var __dirname2 = dirname(fileURLToPath(import.meta.url));
+var packageJson = JSON.parse(
+  readFileSync2(join(__dirname2, "../package.json"), "utf-8")
+);
+var program = new Command();
+program.name("adb").description("AllDebrid CLI - Manage your AllDebrid account from the terminal").version(packageJson.version).option("--api-key <key>", "AllDebrid API key (overrides config file)").option("--json", "Output results in JSON format").hook("preAction", (thisCommand) => {
+  const opts = thisCommand.optsWithGlobals();
+  if (opts.json) {
+    setJsonMode(true);
+  }
+});
+var auth = program.command("auth").description("Manage authentication").action(authInteractive);
+auth.command("login").description("Login with PIN authentication").action(authLogin);
+auth.command("logout").description("Logout and clear saved API key").action(authLogout);
+auth.command("status").description("Check authentication status").action(authStatus);
+var magnet = program.command("magnet").description("Manage magnets and torrents").action(magnetInteractive);
+magnet.command("upload <magnet-or-file>").description("Upload magnet link or torrent file").action(magnetUpload);
+magnet.command("list").description("List all magnets").option("-s, --status <status>", "Filter by status (active|ready|expired|error)").action(async (options) => magnetList(options.status));
+magnet.command("status [id]").description("Get magnet status by ID, or all magnets with --live").option("-l, --live", "Use live mode (delta sync) for monitoring all magnets").option("-s, --session <number>", "Session ID for live mode (auto-generated if not provided)").option("-c, --counter <number>", "Counter for live mode synchronization").action(async (id, options) => {
+  const opts = {
+    live: options.live,
+    session: options.session ? Number.parseInt(options.session) : void 0,
+    counter: options.counter ? Number.parseInt(options.counter) : void 0
+  };
+  await magnetStatus(id, opts);
+});
+magnet.command("watch <id>").description("Monitor magnet progress in real-time").action(async (id) => magnetWatch(id));
+magnet.command("files <id>").description("Get download links for magnet").action(magnetFiles);
+magnet.command("delete <id>").description("Delete magnet").action(magnetDelete);
+magnet.command("restart <id>").description("Restart failed magnet").action(magnetRestart);
+var link = program.command("link").description("Manage premium links").action(linkInteractive);
+link.command("unlock <url>").description("Unlock premium link").option("-p, --password <password>", "Password for protected link").action(async (url, options) => linkUnlock(url, options.password));
+link.command("info <url>").description("Get link information").option("-p, --password <password>", "Password for protected link").action(async (url, options) => linkInfo(url, options.password));
+link.command("stream <id> <stream>").description('Get streaming link (e.g., "original", "1080p")').action(linkStream);
+link.command("redirector <url>").description("Extract links from redirector").action(linkRedirector);
+var user = program.command("user").description("User account management").action(userInteractive);
+user.command("info").description("View account information").action(userInfo);
+user.command("saved-list").description("List saved links").action(userSavedList);
+user.command("saved-add <url>").description("Save a link").action(userSavedAdd);
+user.command("saved-delete <link>").description("Delete a saved link").action(userSavedDelete);
+user.command("history").description("View download history").action(userHistory);
+user.command("history-clear").description("Clear download history").action(userHistoryClear);
+var host = program.command("host").description("List supported hosts").action(async () => hostList(false));
+host.command("list").description("List all supported hosts with status").option("--hosts-only", "Show only host names").action(async (options) => hostList(options.hostsOnly));
+host.command("domains").description("List all supported domains").action(hostDomains);
+var voucher = program.command("voucher").description("Manage vouchers (reseller accounts only)").action(voucherInteractive);
+voucher.command("balance").description("Check voucher balance").action(voucherBalance);
+voucher.command("list").description("List vouchers").option("-q, --quantity <n>", "Number of vouchers to list").action(async (options) => voucherList(options.quantity ? Number.parseInt(options.quantity) : void 0));
+voucher.command("generate <quantity> <days>").description("Generate vouchers").action(async (quantity, days) => voucherGenerate(Number.parseInt(quantity), Number.parseInt(days)));
+program.parse();