node-hp-scan-to 1.2.2 → 1.3.1

package/src/index.ts

@@ -4,498 +4,147 @@
 "use strict";
 
 import os from "os";
-import fs from "fs/promises";
-import { Command } from "commander";
+import { Command, Option, OptionValues, program } from "commander";
 import Bonjour from "bonjour";
-
-import Destination from "./Destination";
-import ScanJobSettings from "./ScanJobSettings";
-import Event from "./Event";
+import config from "config";
 import HPApi from "./HPApi";
-import Job from "./Job";
-import WalkupScanDestination from "./WalkupScanDestination";
-import WalkupScanToCompDestination from "./WalkupScanToCompDestination";
-import JpegUtil from "./JpegUtil";
 import PathHelper from "./PathHelper";
-import { createPdfFrom, ScanContent, ScanPage } from "./ScanContent";
-
-const program = new Command();
-
-function delay(t: number): Promise<void> {
-  return new Promise(function (resolve) {
-    setTimeout(resolve, t);
-  });
-}
-
-async function waitForScanEvent(
-  resourceURI: string,
-  afterEtag: string | null = null
-): Promise<Event> {
-  console.log("Start listening for new ScanEvent");
-
-  let eventTable = await HPApi.getEvents(afterEtag ?? "");
-  let acceptedScanEvent = null;
-  let currentEtag = eventTable.etag;
-  while (acceptedScanEvent == null) {
-    eventTable = await HPApi.getEvents(currentEtag, 1200);
-    currentEtag = eventTable.etag;
-
-    acceptedScanEvent = eventTable.eventTable.events.find(
-      (ev) =>
-        ev.isScanEvent &&
-        ev.destinationURI &&
-        ev.destinationURI.indexOf(resourceURI) >= 0
-    );
-  }
-  return acceptedScanEvent;
-}
-
-async function waitPrinterUntilItIsReadyToUploadOrCompleted(
-  jobUrl: string
-): Promise<Job> {
-  let job = null;
-  let isReadyToUpload = false;
-  do {
-    job = await HPApi.getJob(jobUrl);
-    if (job.jobState === "Canceled") {
-      return job;
-    } else if (
-      job.pageState === "ReadyToUpload" ||
-      job.jobState === "Completed"
-    ) {
-      isReadyToUpload = true;
-    } else if (job.jobState == "Processing") {
-      isReadyToUpload = false;
-    } else {
-      console.log(`Unknown jobState: ${job.jobState}`);
-    }
-    await delay(300);
-  } while (!isReadyToUpload);
-  return job;
-}
-
-async function register(): Promise<string> {
-  let destination;
-  const hostname = os.hostname();
-  const toComp = await HPApi.getWalkupScanToCompCaps();
-
-  if (toComp) {
-    const walkupScanDestinations =
-      await HPApi.getWalkupScanToCompDestinations();
-    const destinations = walkupScanDestinations.destinations;
-
-    console.log(
-      "Host destinations fetched:",
-      destinations.map((d) => d.name).join(", ")
-    );
-
-    destination = destinations.find((x) => x.name === hostname);
-  } else {
-    const walkupScanDestinations = await HPApi.getWalkupScanDestinations();
-    const destinations = walkupScanDestinations.destinations;
-
-    console.log(
-      "Host destinations fetched:",
-      destinations.map((d) => d.name).join(", ")
-    );
-
-    destination = destinations.find((x) => x.name === hostname);
-  }
-
-  let resourceURI;
-  if (destination) {
-    console.log(
-      `Re-using existing destination: ${hostname} - ${destination.resourceURI}`
-    );
-    resourceURI = destination.resourceURI;
-  } else {
-    resourceURI = await HPApi.registerDestination(
-      new Destination(hostname, hostname, toComp),
-      toComp
-    );
-    console.log(`New Destination registered: ${hostname} - ${resourceURI}`);
-  }
-  return resourceURI;
-}
-
-async function TryGetDestination(event: Event) {
-  //this code can in some cases be executed before the user actually chooses between Document or Photo
-  //so lets fetch the contentType (Document or Photo) until we get a value
-  let destination: WalkupScanDestination | WalkupScanToCompDestination | null =
-    null;
-
-  for (let i = 0; i < 20; i++) {
-    const destinationURI = event.destinationURI;
-    if (destinationURI) {
-      destination = await HPApi.getDestination(destinationURI);
-
-      const shortcut = destination.shortcut;
-      if (shortcut !== "") {
-        return destination;
-      }
-    } else {
-      console.log(`No destination URI found`);
-    }
-
-    console.log(`No shortcut yet available, attempt: ${i + 1}/20`);
-    await new Promise((resolve) => setTimeout(resolve, 1000)); //wait 1s
-  }
-
-  console.log("Failing to detect destination shortcut");
-  console.log(JSON.stringify(destination));
-  return null;
-}
-
-async function fixJpegSize(filePath: string): Promise<number | null> {
-  const buffer: Buffer = await fs.readFile(filePath);
-
-  let height = JpegUtil.fixSizeWithDNL(buffer);
-  if (height != null) {
-    // rewrite the fixed file
-    await fs.writeFile(filePath, buffer);
-    return height;
-  }
-  return null;
-}
-
-function createScanPage(
-  job: Job,
-  currentPageNumber: number,
-  filePath: string,
-  sizeFixed: number | null
-): ScanPage {
-  let height = sizeFixed ?? job.imageHeight;
-  return {
-    path: filePath,
-    pageNumber: currentPageNumber,
-    width: job.imageWidth,
-    height,
-    xResolution: job.xResolution,
-    yResolution: job.yResolution,
-  };
-}
-
-async function handleProcessingState(
-  job: Job,
-  inputSource: "Adf" | "Platen",
-  folder: string,
-  scanCount: number,
-  currentPageNumber: number
-): Promise<ScanPage | null> {
-  if (
-    job.pageState == "ReadyToUpload" &&
-    job.binaryURL != null &&
-    job.currentPageNumber != null
-  ) {
-    console.log(
-      `Ready to download page job page ${job.currentPageNumber} at:`,
-      job.binaryURL
-    );
-
-    const destinationFilePath = PathHelper.getFileForPage(
-      folder,
-      scanCount,
-      currentPageNumber,
-      program.opts().pattern,
-      "jpg"
-    );
-    const filePath = await HPApi.downloadPage(
-      job.binaryURL,
-      destinationFilePath
-    );
-    console.log("Page downloaded to:", filePath);
-
-    let sizeFixed: null | number = null;
-    if (inputSource == "Adf") {
-      sizeFixed = await fixJpegSize(filePath);
-      if (sizeFixed == null) {
-        console.log(
-          `File size has not been fixed, DNF may not have been found and approximate height is: ${job.imageHeight}`
-        );
-      }
-    }
-    return createScanPage(job, currentPageNumber, filePath, sizeFixed);
-  } else {
-    console.log(`Unknown pageState: ${job.pageState}`);
-    await delay(200);
-    return null;
-  }
-}
-
-async function waitScanRequest(compEventURI: string): Promise<boolean> {
-  const waitMax = 50;
-  for (let i = 0; i < waitMax; i++) {
-    let walkupScanToCompEvent = await HPApi.getWalkupScanToCompEvent(
-      compEventURI
-    );
-    let message = walkupScanToCompEvent.eventType;
-    if (message === "HostSelected") {
-      // this ok to wait
-    } else if (message === "ScanRequested") {
-      break;
-    } else if (message === "ScanNewPageRequested") {
-      break;
-    } else if (message === "ScanPagesComplete") {
-      console.log("no more page to scan, scan is finished");
-      return false;
-    } else {
-      console.log(`Unknown eventType: ${message}`);
-      return false;
-    }
+import { delay } from "./delay";
+import { readDeviceCapabilities } from "./readDeviceCapabilities";
+import { clearRegistrations, RegistrationConfig, waitScanEvent } from "./listening";
+import { AdfAutoScanConfig, DirectoryConfig, saveScan, ScanConfig, scanFromAdf, waitAdfLoaded } from "./scanProcessing";
 
-    console.log(`Waiting user input: ${i + 1}/${waitMax}`);
-    await new Promise((resolve) => setTimeout(resolve, 1000)); //wait 1s
-  }
-  return true;
-}
+let iteration = 0;
 
-async function executeScanJob(
-  scanJobSettings: ScanJobSettings,
-  inputSource: "Adf" | "Platen",
-  folder: string,
-  scanCount: number,
-  scanJobContent: ScanContent
+async function listenCmd(
+  registrationConfig: RegistrationConfig,
+  scanConfig: ScanConfig,
+  deviceUpPollingInterval: number
 ) {
-  const jobUrl = await HPApi.postJob(scanJobSettings);
+  // first make sure the device is reachable
+  await HPApi.waitDeviceUp(deviceUpPollingInterval);
+  let deviceUp = true;
 
-  console.log("New job created:", jobUrl);
+  const folder = await PathHelper.getOutputFolder(
+    scanConfig.directoryConfig.directory
+  );
+  console.log(`Target folder: ${folder}`);
 
-  let job = await HPApi.getJob(jobUrl);
-  while (job.jobState !== "Completed") {
-    job = await waitPrinterUntilItIsReadyToUploadOrCompleted(jobUrl);
+  const tempFolder = await PathHelper.getOutputFolder(
+    scanConfig.directoryConfig.tempDirectory
+  );
+  console.log(`Temp folder: ${tempFolder}`);
 
-    if (job.jobState == "Completed") {
-      continue;
-    }
+  const deviceCapabilities = await readDeviceCapabilities();
 
-    if (job.jobState === "Processing") {
-      const page = await handleProcessingState(
-        job,
-        inputSource,
+  let scanCount = 0;
+  let keepActive = true;
+  let errorCount = 0;
+  while (keepActive) {
+    console.log(`Running iteration: ${iteration} - errorCount: ${errorCount}`);
+    try {
+      const event = await waitScanEvent(deviceCapabilities, registrationConfig);
+      scanCount++;
+      console.log(`Scan event captured, saving scan #${scanCount}`);
+      await saveScan(
+        event,
         folder,
+        tempFolder,
         scanCount,
-        scanJobContent.elements.length + 1
+        deviceCapabilities,
+        scanConfig
       );
-      if (page != null) {
-        scanJobContent.elements.push(page);
+    } catch (e) {
+      console.log(e);
+      if (await HPApi.isAlive()) {
+        errorCount++;
+      } else {
+        deviceUp = false;
       }
-    } else if (job.jobState === "Canceled") {
-      console.log("Job cancelled by device");
-      break;
-    } else {
-      console.log(`Unhandled jobState: ${job.jobState}`);
-      await delay(200);
     }
-  }
-  console.log(
-    `Job state: ${job.jobState}, totalPages: ${job.totalPageNumber}:`
-  );
-}
 
-async function waitScanNewPageRequest(compEventURI: string): Promise<boolean> {
-  let startNewScanJob = false;
-  let wait = true;
-  while (wait) {
-    await new Promise((resolve) => setTimeout(resolve, 1000)); //wait 1s
+    if (errorCount === 50) {
+      keepActive = false;
+    }
 
-    let walkupScanToCompEvent = await HPApi.getWalkupScanToCompEvent(
-      compEventURI
-    );
-    let message = walkupScanToCompEvent.eventType;
-
-    if (message === "ScanNewPageRequested") {
-      startNewScanJob = true;
-      wait = false;
-    } else if (message === "ScanPagesComplete") {
-      wait = false;
-    } else if (message === "ScanRequested") {
-      // continue waiting
+    if (!deviceUp) {
+      await HPApi.waitDeviceUp(deviceUpPollingInterval);
     } else {
-      wait = false;
-      console.log(`Unknown eventType: ${message}`);
+      await delay(1000);
     }
   }
-  return startNewScanJob;
 }
 
-async function executeScanJobs(
-  scanJobSettings: ScanJobSettings,
-  inputSource: "Adf" | "Platen",
-  folder: string,
-  scanCount: number,
-  scanJobContent: ScanContent,
-  firstEvent: Event
+async function adfAutoscanCmd(
+  adfAutoScanConfig: AdfAutoScanConfig,
+  deviceUpPollingInterval: number
 ) {
-  await executeScanJob(
-    scanJobSettings,
-    inputSource,
-    folder,
-    scanCount,
-    scanJobContent
-  );
-  let lastEvent = firstEvent;
-  if (
-    lastEvent.compEventURI &&
-    inputSource !== "Adf" &&
-    lastEvent.destinationURI
-  ) {
-    lastEvent = await waitForScanEvent(
-      lastEvent.destinationURI,
-      lastEvent.agingStamp
-    );
-    if (!lastEvent.compEventURI) {
-      return;
-    }
-    let startNewScanJob = await waitScanNewPageRequest(lastEvent.compEventURI);
-    while (startNewScanJob) {
-      await executeScanJob(
-        scanJobSettings,
-        inputSource,
-        folder,
-        scanCount,
-        scanJobContent
-      );
-      if (!lastEvent.destinationURI) {
-        break;
-      }
-      lastEvent = await waitForScanEvent(
-        lastEvent.destinationURI,
-        lastEvent.agingStamp
-      );
-      if (!lastEvent.compEventURI) {
-        return;
-      }
-      startNewScanJob = await waitScanNewPageRequest(lastEvent.compEventURI);
-    }
-  }
-}
-
-async function mergeToPdf(folder: string, scanCount: number, scanJobContent: ScanContent) {
-  const pdfFilePath = PathHelper.getFileForScan(
-    folder,
-    scanCount,
-    program.opts().pattern,
-    "pdf"
-  );
-  await createPdfFrom(scanJobContent, pdfFilePath);
-  scanJobContent.elements.forEach((e) => fs.unlink(e.path));
-  return pdfFilePath;
-}
+  // first make sure the device is reachable
+  await HPApi.waitDeviceUp(deviceUpPollingInterval);
+  let deviceUp = true;
 
-function displayPdfScan(pdfFilePath: string, scanJobContent: ScanContent) {
-  console.log(
-    `The following page(s) have been rendered inside '${pdfFilePath}': `
-  );
-  scanJobContent.elements.forEach((e) =>
-    console.log(
-      `\t- page ${e.pageNumber.toString().padStart(3, " ")} - ${e.width}x${
-        e.height
-      }`
-    )
-  );
-}
-
-function displayJpegScan(scanJobContent: ScanContent) {
-  scanJobContent.elements.forEach((e) =>
-    console.log(
-      `\t- page ${e.pageNumber.toString().padStart(3, " ")} - ${e.width}x${
-        e.height
-      } - ${e.path}`
-    )
-  );
-}
-
-async function saveScan(
-  event: Event,
-  folder: string,
-  scanCount: number
-): Promise<void> {
-  if (event.compEventURI) {
-    const proceedToScan = await waitScanRequest(event.compEventURI);
-    if (!proceedToScan) {
-      return;
-    }
-  }
-
-  const destination = await TryGetDestination(event);
-  if (!destination) {
-    console.log("No shortcut selected!");
-    return;
-  }
-  console.log("Selected shortcut: " + destination.shortcut);
-
-  const contentType = destination.getContentType();
-  const toPdf =
-    destination.shortcut === "SavePDF" || destination.shortcut === "EmailPDF";
-
-  const scanStatus = await HPApi.getScanStatus();
-  console.log("Afd is : " + scanStatus.adfState);
-
-  let inputSource = scanStatus.getInputSource();
-
-  let scanJobSettings = new ScanJobSettings(inputSource, contentType);
-
-  let scanJobContent: ScanContent = { elements: [] };
-
-  await executeScanJobs(
-    scanJobSettings,
-    inputSource,
-    folder,
-    scanCount,
-    scanJobContent,
-    event
+  const folder = await PathHelper.getOutputFolder(
+    adfAutoScanConfig.directoryConfig.directory
   );
+  console.log(`Target folder: ${folder}`);
 
-  console.log(
-    `Scan of page(s) completed totalPages: ${scanJobContent.elements.length}:`
+  const tempFolder = await PathHelper.getOutputFolder(
+    adfAutoScanConfig.directoryConfig.tempDirectory
   );
-
-  if (toPdf) {
-    const pdfFilePath = await mergeToPdf(folder, scanCount, scanJobContent);
-    displayPdfScan(pdfFilePath, scanJobContent);
-  } else {
-    displayJpegScan(scanJobContent);
-  }
-}
-
-let iteration = 0;
-async function init() {
-  const folder = await PathHelper.getOutputFolder(program.opts().directory);
-  console.log(`Target folder: ${folder}`);
+  console.log(`Temp folder: ${tempFolder}`);
 
   let scanCount = 0;
-
   let keepActive = true;
   let errorCount = 0;
   while (keepActive) {
     console.log(`Running iteration: ${iteration} - errorCount: ${errorCount}`);
     try {
-      let resourceURI = await register();
-
-      console.log("Waiting scan event for:", resourceURI);
-      const event = await waitForScanEvent(resourceURI);
+      await waitAdfLoaded(
+        adfAutoScanConfig.pollingInterval,
+        adfAutoScanConfig.startScanDelay
+      );
 
       scanCount++;
+
       console.log(`Scan event captured, saving scan #${scanCount}`);
-      await saveScan(event, folder, scanCount);
+
+      await scanFromAdf(scanCount, folder, tempFolder, adfAutoScanConfig);
     } catch (e) {
-      errorCount++;
-      console.error(e);
       console.log(e);
+      if (await HPApi.isAlive()) {
+        errorCount++;
+      } else {
+        deviceUp = false;
+      }
     }
 
     if (errorCount === 50) {
       keepActive = false;
     }
 
-    await delay(1000);
+    if (!deviceUp) {
+      await HPApi.waitDeviceUp(deviceUpPollingInterval);
+    } else {
+      await delay(1000);
+    }
   }
 }
 
-function findOfficejetIp(): Promise<string> {
+async function clearRegistrationsCmd(cmd: Command) {
+  const parentOption = cmd.parent!.opts();
+
+  const ip = await getDeviceIp(parentOption);
+  HPApi.setDeviceIP(ip);
+
+  const isDebug = getIsDebug(parentOption);
+  HPApi.setDebug(isDebug);
+  await clearRegistrations();
+}
+
+function findOfficejetIp(deviceNamePrefix: string): Promise<string> {
   return new Promise((resolve) => {
     const bonjour = Bonjour();
-    console.log("Searching printer...");
+    console.log("Searching device...");
     let browser = bonjour.find(
       {
         type: "http",
@@ -503,7 +152,7 @@ function findOfficejetIp(): Promise<string> {
       (service) => {
         console.log(".");
         if (
-          service.name.startsWith(program.opts().name) &&
+          service.name.startsWith(deviceNamePrefix) &&
           service.port === 80 &&
           service.type === "http" &&
           service.addresses != null
@@ -519,37 +168,190 @@ function findOfficejetIp(): Promise<string> {
   });
 }
 
-async function main() {
-  program.option(
-    "-ip, --address <ip>",
-    "IP address of the printer (this overrides -p)"
-  );
-  program.option(
-    "-n, --name <name>",
-    "Name of the printer for service discovery",
-    "HP Smart Tank Plus 570 series"
-  ); //or i.e. 'Deskjet 3520 series'
-  program.option(
+function getConfig<T>(name: string): T | undefined {
+  return config.has(name) ? config.get<T>(name) : undefined;
+}
+
+function setupScanParameters(command: Command): Command {
+  command.option(
     "-d, --directory <dir>",
-    "Directory where scans are saved (defaults to /tmp/scan-to-pc<random>)"
+    "Directory where scans are saved (default: /tmp/scan-to-pc<random>)"
   );
-  program.option(
+  command.option(
+    "-t, --temp-directory <dir>",
+    "Temp directory used for processing (default: /tmp/scan-to-pc<random>)"
+  );
+  command.option(
     "-p, --pattern <pattern>",
     'Pattern for filename (i.e. "scan"_dd.mm.yyyy_hh:MM:ss, without this its scanPage<number>)'
   );
-  program.option("-D, --debug", "Enable debug");
-  program.parse(process.argv);
+  command.option(
+    "-r, --resolution <dpi>",
+    "Resolution in DPI of the scans (default: 200)"
+  );
+  return command;
+}
+
+function setupParameterOpts(command: Command): Command {
+  command.option(
+    "-ip, --address <ip>",
+    "IP address of the device (this overrides -p)"
+  );
+  command.option(
+    "--device-up-polling-interval <deviceUpPollingInterval>",
+    "Device up polling interval in milliseconds",
+    parseFloat
+  );
+  command.option(
+    "-n, --name <name>",
+    "Name of the device for service discovery"
+  ); // i.e. 'Deskjet 3520 series'
 
-  let ip = program.opts().address || "192.168.1.53";
+  command.option("-D, --debug", "Enable debug");
+  return command;
+}
+
+async function getDeviceIp(options: OptionValues) {
+  let ip = options.address || getConfig("ip");
   if (!ip) {
-    ip = await findOfficejetIp();
+    const name = options.name || getConfig("name");
+    ip = await findOfficejetIp(name || "HP Smart Tank Plus 570 series");
   }
+  console.log(`Using device ip: ${ip}`);
+  return ip;
+}
+
+function getIsDebug(options: OptionValues) {
+  const debug =
+    options.debug != null ? true : getConfig<boolean>("debug") || false;
+
+  if (debug) {
+    console.log(`IsDebug: ${debug}`);
+  }
+  return debug;
+}
+
+function getScanConfiguration(parentOption: OptionValues) {
+  const directoryConfig: DirectoryConfig = {
+    directory: parentOption.directory || getConfig("directory"),
+    tempDirectory: parentOption.tempDirectory || getConfig("tempDirectory"),
+    filePattern: parentOption.pattern || getConfig("pattern"),
+  };
+
+  const scanConfig: ScanConfig = {
+    resolution: parseInt(
+      parentOption.resolution || getConfig("resolution") || 200,
+      10
+    ),
+    directoryConfig,
+  };
+  return scanConfig;
+}
+
+function getDeviceUpPollingInterval(parentOption: OptionValues) {
+  return (
+    parentOption.deviceUpPollingInterval ||
+    getConfig("deviceUpPollingInterval") ||
+    1000
+  );
+}
+
+
+async function main() {
+  setupParameterOpts(program);
+  const cmdListen = program.createCommand("listen");
+  setupScanParameters(cmdListen)
+    .description("Listen the device for new scan job to save to this target")
+    .option(
+      "-l, --label <label>",
+      "The label to display on the device (the default is the hostname)"
+    )
+    .action(async (options, cmd) => {
+      const parentOption = cmd.parent.opts();
 
-  const debug = program.opts().debug != null;
+      const ip = await getDeviceIp(parentOption);
+      HPApi.setDeviceIP(ip);
 
-  HPApi.setDebug(debug);
-  HPApi.setPrinterIP(ip);
-  await init();
+      const isDebug = getIsDebug(parentOption);
+      HPApi.setDebug(isDebug);
+
+      const registrationConfig: RegistrationConfig = {
+        label: options.label || getConfig("label") || os.hostname(),
+      };
+
+      const deviceUpPollingInterval = getDeviceUpPollingInterval(parentOption);
+
+      const scanConfig = getScanConfiguration(options);
+
+      await listenCmd(registrationConfig, scanConfig, deviceUpPollingInterval);
+    });
+  program.addCommand(cmdListen, { isDefault: true });
+
+  const cmdAdfAutoscan = program.createCommand("adf-autoscan");
+  setupScanParameters(cmdAdfAutoscan)
+    .addOption(
+      new Option("--duplex", "If specified, the scan will be in duplex")
+    )
+    .addOption(
+      new Option(
+        "--pdf",
+        "If specified, the scan result will be a pdf document, the default is multiple jpeg files"
+      )
+    )
+    .addOption(
+      new Option(
+        "--pollingInterval <pollingInterval>",
+        "Time interval in millisecond between each lookup for content in the automatic document feeder",
+      )
+    )
+    .description(
+      "Automatically trigger a new scan job to this target once paper is detected in the automatic document feeder (adf)"
+    )
+    .addOption(
+      new Option(
+        "--start-scan-delay <startScanDelay>",
+        "Once document are detected to be in the adf, this specify the wait delay in millisecond before triggering the scan",
+      )
+    )
+    .description(
+      "Automatically trigger a new scan job to this target once paper is detected in the automatic document feeder (adf)"
+    )
+    .action(async (options, cmd) => {
+      const parentOption = cmd.parent.opts();
+
+      const ip = await getDeviceIp(parentOption);
+      HPApi.setDeviceIP(ip);
+
+      const isDebug = getIsDebug(parentOption);
+      HPApi.setDebug(isDebug);
+
+      const deviceUpPollingInterval = getDeviceUpPollingInterval(parentOption);
+
+      const scanConfig = getScanConfiguration(options);
+
+      const adfScanConfig: AdfAutoScanConfig = {
+        ...scanConfig,
+        isDuplex: options.isDuplex || getConfig("autoscan_duplex") || false,
+        generatePdf: options.pdf || getConfig("autoscan_pdf") || false,
+        pollingInterval:
+          options.pollingInterval || getConfig("autoscan_pollingInterval") || 1000,
+        startScanDelay:
+          options.startScanDelay || getConfig("autoscan_startScanDelay") || 5000,
+      };
+
+      await adfAutoscanCmd(adfScanConfig, deviceUpPollingInterval);
+    });
+  program.addCommand(cmdAdfAutoscan);
+
+  const cmdClearRegistrations = program.createCommand("clear-registrations");
+  cmdClearRegistrations
+    .description("Clear the list or registered target on the device")
+    .action(async (options, cmd) => {
+      await clearRegistrationsCmd(cmd);
+    });
+  program.addCommand(cmdClearRegistrations);
+
+  await program.parseAsync(process.argv);
 }
 
-main();
+main().catch((err) => console.log(err));