sentinel-scanner 1.0.1 → 1.1.0-alpha.2

package/.cspell.json

@@ -2,16 +2,33 @@
   "version": "0.2",
   "language": "en",
   "words": [
+    "acmr",
+    "codebases",
+    "datetime",
     "degit",
+    "domcontentloaded",
+    "dynsrc",
+    "dynsrcs",
     "esbuild",
-    "webapp-scanner",
+    "esportzvio",
+    "hrefs",
+    "khtml",
+    "longdesc",
+    "longdescs",
+    "lowsrc",
+    "lowsrcs",
+    "muzaffarpur",
+    "networkidle",
     "octocat",
     "outdir",
+    "rebackk",
     "rmrf",
-    "ryansonshine",
     "socio",
+    "srcs",
     "tsdoc",
-    "rebackk"
+    "webapp-scanner",
+    "wordlist",
+    "xlink"
   ],
   "flagWords": [],
   "ignorePaths": [

package/.github/workflows/pr.yaml

@@ -0,0 +1,86 @@
+name: "check PR"
+
+on: [push]
+
+permissions: "write-all"
+
+jobs:
+  dependencies:
+    name: 📦 Dependencies
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version-file: package.json
+          cache: "npm"
+      - run: npm ci
+
+  lint:
+    name: 🔬 Lint & Format
+    runs-on: macos-latest
+    needs: [dependencies]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version-file: package.json
+          cache: "npm"
+      - run: npm ci
+      - name: 🔬 Lint & Format
+        run: node --run lint:check
+
+  audit:
+    name: 🛡️ Audit
+    runs-on: macos-latest
+    needs: [dependencies]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version-file: package.json
+          cache: "npm"
+      - name: 🛡️ Audit
+        run: npm audit --audit-level=high
+
+  spell:
+    name: 🈸 Spellcheck
+    runs-on: macos-latest
+    needs: [dependencies]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version-file: package.json
+          cache: "npm"
+      - run: npm ci
+      - name: 🈸 Spellcheck
+        run: node --run spell:check
+
+  type:
+    name: ʦ Typecheck
+    runs-on: macos-latest
+    needs: [dependencies]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version-file: package.json
+          cache: "npm"
+      - run: npm ci
+      - name: ʦ Typecheck
+        run: node --run type:check
+
+  test:
+    name: ⚡ Tests
+    runs-on: macos-latest
+    needs: [dependencies]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version-file: package.json
+          cache: "npm"
+      - run: npm ci
+      - name: ⚡ Tests
+        run: node --run test:coverage

package/.github/workflows/welcome.yaml

@@ -0,0 +1,66 @@
+name: Welcome Comments
+
+permissions: "write-all"
+
+on:
+  issues:
+    types: [opened, closed]
+  pull_request_target:
+    types: [opened, closed]
+
+jobs:
+  welcomer:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Auto Welcome on Issues or PRs
+        uses: actions/github-script@v6
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            const author = context.payload.sender.login;
+            const commentBody = (message) => `👋 @${author} 👋\n\n${message}`;
+
+            if (context.eventName === 'issues') {
+              const issue = context.payload.issue;
+
+              if (context.payload.action === 'opened') {
+                const message = `We're thrilled to see you opening an issue! Your input is valuable to us. Don’t forget to fill out our issue template for the best experience. We will look into it soon.`;
+                github.rest.issues.createComment({
+                  issue_number: issue.number,
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  body: commentBody(message),
+                });
+              } else if (context.payload.action === 'closed') {
+                const message = `Thanks for closing the issue! We appreciate your updates.`;
+                github.rest.issues.createComment({
+                  issue_number: issue.number,
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  body: commentBody(message),
+                });
+              }
+            } else if (context.eventName === 'pull_request_target') {
+              const pr = context.payload.pull_request;
+
+              if (context.payload.action === 'opened') {
+                const message = `We're delighted to have your pull request! Please take a moment to check our contributing guidelines and ensure you've filled out the PR template for a smooth process. We will review it soon.`;
+                github.rest.issues.createComment({
+                  issue_number: pr.number,
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  body: commentBody(message),
+                });
+              } else if (context.payload.action === 'closed') {
+            		const message = pr.merged 
+                  ? `🎉 You've just merged your pull request! We're excited to have you in our community. Keep up the fantastic contributions to the project!`
+                  : `Thanks for closing the pull request! Your contributions are valuable to us.`;
+                
+                github.rest.issues.createComment({
+                  issue_number: pr.number,
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  body: commentBody(message),
+                });
+              }
+            }

package/CHANGELOG.md

@@ -1,6 +1,6 @@
-## [1.0.1](https://github.com/RebackkHQ/webapp-scanner/compare/v1.0.0...v1.0.1) (2024-11-07)
+# [1.1.0-alpha.2](https://github.com/RebackkHQ/webapp-scanner/compare/v1.1.0-alpha.1...v1.1.0-alpha.2) (2024-11-15)
 
 
-### Bug Fixes
+### Features
 
-* fixed compatibility with npx ([a778b5a](https://github.com/RebackkHQ/webapp-scanner/commit/a778b5a97140fb67cf503d72dac59adc571316a3))
+* finalized Spider ([17127e9](https://github.com/RebackkHQ/webapp-scanner/commit/17127e99ec82befb4bdf1c2702215d5f9266465e))

package/DISCLAIMER.md

@@ -0,0 +1,64 @@
+# DISCLAIMER
+
+Last Updated: **10/11/2024**
+
+### 1. General Information
+
+This web vulnerability scanner (“the Tool”) is provided by Esportzvio Private Limited (“the Company”) under the product name Sentinel. The Tool is designed to identify potential security vulnerabilities in web applications and APIs. It is intended solely for educational and informational purposes to help enhance cybersecurity. By using this Tool, you acknowledge that you have read, understood, and agreed to the terms of this Disclaimer.
+
+### 2. No Guarantee of Security
+
+The Tool is designed to detect certain security vulnerabilities; however, it does not guarantee that your website, application, or network will be free from security threats or that all vulnerabilities will be detected. The Company makes no representations or warranties regarding the completeness, accuracy, or effectiveness of the Tool’s scanning capabilities. Security is a complex field, and this Tool should be used as part of a broader security strategy.
+
+### 3. Use at Your Own Risk
+
+By using the Tool, you acknowledge that you do so at your own risk. The Company is not responsible for any direct, indirect, incidental, special, or consequential damages, losses, or liabilities resulting from the use of the Tool, including but not limited to data loss, system downtime, unauthorized access, security breaches, or legal implications. It is strongly recommended that you use the Tool only on non-production environments or systems where you have full ownership and authorization.
+
+### 4. Authorization to Scan
+
+You must obtain explicit written permission from the website, application, or network owner before using the Tool to scan any system. Unauthorized use of this Tool on systems that you do not own or have explicit permission to test is strictly prohibited and may be illegal, potentially resulting in civil, criminal, or regulatory penalties. The Company disclaims all responsibility for any misuse of the Tool, including any legal consequences that may arise from unauthorized usage.
+
+### 5. Ethical Usage Clause
+
+The Tool is intended solely for ethical security testing purposes. By using this Tool, you agree to:
+- Only scan systems for which you have obtained explicit written consent from the system owner.
+- Not use the Tool for any illegal, unethical, or malicious activities, including but not limited to unauthorized hacking, data theft, denial of service attacks, or any form of exploitation.
+- Ensure compliance with all applicable local, national, and international laws and regulations related to cybersecurity, data protection, and privacy.
+- Refrain from sharing, distributing, or using the Tool for purposes that could harm, disrupt, or compromise any system without proper authorization.
+
+Any misuse of this Tool for malicious purposes, unethical hacking, or unauthorized access to systems is strictly prohibited and will result in immediate termination of your access to the Tool, along with potential legal action by the Company.
+
+### 6. No Legal or Professional Advice
+
+The results and outputs of the Tool are provided for informational purposes only and should not be considered a substitute for professional cybersecurity advice. The Company is not liable for any decisions or actions taken based on the Tool’s findings. Always consult with a qualified cybersecurity professional before implementing any security measures based on the Tool’s results.
+
+### 7. Limitation of Liability
+
+To the fullest extent permitted by law, the Company, its affiliates, partners, and licensors shall not be liable for any direct, indirect, incidental, special, consequential, or punitive damages, including but not limited to loss of profits, revenue, data, or other intangible losses arising from or in connection with your use or misuse of the Tool, regardless of whether the Company has been advised of the possibility of such damages.
+
+### 8. Indemnification
+
+You agree to indemnify, defend, and hold harmless the Company, its officers, directors, employees, agents, and affiliates from any and all claims, liabilities, damages, losses, or expenses, including reasonable attorneys’ fees, arising out of or in any way connected with:
+- Your access to or use of the Tool.
+- Your violation of any terms of this Disclaimer.
+- Your violation of any rights of a third party, including intellectual property rights.
+- Your violation of any applicable laws or regulations.
+
+### 9. Compliance with Laws
+
+By using this Tool, you agree to comply with all applicable laws, regulations, and guidelines, including but not limited to data protection laws, cybersecurity laws, and any other regulations relevant to your jurisdiction. The Company is not responsible for any violations of the law resulting from your use of the Tool.
+
+### 10. Changes to This Disclaimer
+
+The Company reserves the right to modify, update, or change this Disclaimer at any time without prior notice. Your continued use of the Tool after any changes are made constitutes your acceptance of the revised Disclaimer. It is your responsibility to review this Disclaimer periodically for updates.
+
+### 11. Governing Law and Jurisdiction
+
+This Disclaimer shall be governed by and construed in accordance with the laws of India, without regard to its conflict of laws principles. Any disputes arising out of or related to this Disclaimer or your use of the Tool shall be subject to the exclusive jurisdiction of the courts located in Muzaffarpur, Bihar, India.
+
+### 12. Contact Information
+
+If you have any questions, concerns, or require further clarification regarding this Disclaimer, please contact us at:
+
+- Email: **legal@esportzvio.com**
+- Address: **Esportzvio Private Limited, Muzaffarpur, Bihar, 842001, India.**

package/LICENSE

@@ -1,7 +1,7 @@
-
-                                 Apache License
+                              Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/
+   DISCLAIMER: Use of this tool is subject to the terms outlined in ./DISCLAIMER.md.
 
    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 

package/README.md

@@ -2,7 +2,14 @@
   <h1 align="center">
     Sentinel By Rebackk (Work in progress)
     <br />
-    <img src="https://github.com/RebackkHQ/webapp-scanner/actions/workflows/webapp-scanner.yml/badge.svg" style="padding: 15px;" />
+    <img src="https://img.shields.io/github/actions/workflow/status/RebackkHQ/webapp-scanner/.github%2Fworkflows%2Fwebapp-scanner.yml" style="padding-top: 15px;" />
+    <img src="https://img.shields.io/github/contributors/RebackkHQ/webapp-scanner" style="padding-top: 15px;" />
+    <img src="https://img.shields.io/github/issues-raw/RebackkHQ/webapp-scanner" style="padding-top: 15px;" />
+    <img src="https://img.shields.io/github/v/release/RebackkHQ/webapp-scanner?include_prereleases" style="padding-top: 15px;" />
+    <img src="https://img.shields.io/npm/dw/sentinel-scanner" style="padding-top: 15px;" />
+    <div>
+      <img src="https://img.shields.io/github/stars/RebackkHQ/webapp-scanner" style="padding-top: 15px;" />
+    </div>
   </h3>
   <p align="center">
     <a href="https://www.sentinel.rebackk.xyz">
@@ -50,6 +57,18 @@ Happy Scanning! 🛡️
 ## Contributing 🤝
 If you want to help us building the best status page and alerting system, you can check our [contributing guidelines](./CODE_OF_CONDUCT.md)
 
+## Disclaimer
+
+By using Sentinel, you agree to the terms outlined in our [DISCLAIMER](./DISCLAIMER.md). It is **strongly recommended** that you read the disclaimer thoroughly before using this tool. 
+
+**Key points include:**
+
+- Only scan systems for which you have explicit permission.
+- The tool is provided "as is" without any warranties.
+- The company is not liable for any misuse, damages, or legal issues arising from the use of this tool.
+
+You can find the full disclaimer [here](./DISCLAIMER.md).
+
 ---
 
 **This is a work in progress project**

package/build/bin.js

@@ -0,0 +1,376 @@
+#!/usr/bin/env node --no-warnings
+
+// src/bin.ts
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+// src/commands/spider.ts
+import fs from "node:fs";
+import path from "node:path";
+
+// src/modules/spider/index.ts
+import fetch from "isomorphic-fetch";
+import jsdom from "jsdom";
+import UserAgent from "user-agents";
+
+// src/utils/index.ts
+import winston from "winston";
+var createLogger = (label) => winston.createLogger({
+  levels: {
+    error: 0,
+    warn: 1,
+    info: 2,
+    http: 3,
+    verbose: 4,
+    debug: 5,
+    silly: 6
+  },
+  format: winston.format.combine(
+    winston.format.label({ label }),
+    winston.format.colorize(),
+    winston.format.timestamp({
+      format: () => {
+        return (/* @__PURE__ */ new Date()).toLocaleString("en-US");
+      }
+    }),
+    winston.format.align(),
+    winston.format.printf(
+      (info) => `\x1B[34m(${info.label})\x1B[0m \x1B[33m${info.timestamp}\x1B[0m [${info.level}]: ${info.message}`
+    )
+  ),
+  transports: [new winston.transports.Console()]
+});
+
+// src/modules/spider/index.ts
+var SpiderScanner = class {
+  header = {
+    "User-Agent": new UserAgent().toString()
+  };
+  url;
+  logger = createLogger("SpiderScanner");
+  depth;
+  concurrency;
+  retries;
+  timeout;
+  constructor(url, options = {}) {
+    const {
+      depth = 250,
+      concurrency = 5,
+      retries = 3,
+      timeout = 5e3
+    } = options;
+    this.depth = depth;
+    this.concurrency = concurrency;
+    this.retries = retries;
+    this.timeout = timeout;
+    try {
+      this.url = new URL(url);
+      this.logger.info(
+        `Initialized with URL: ${url}, User-Agent: ${this.header["User-Agent"]}`
+      );
+    } catch (error) {
+      if (error instanceof TypeError) {
+        this.logger.error("Invalid URL");
+        throw new Error("Invalid URL");
+      }
+      this.logger.error(`Unexpected error in constructor: ${error}`);
+      throw error;
+    }
+  }
+  normalizeDomain(domain) {
+    return domain.startsWith("www.") ? domain.slice(4) : domain;
+  }
+  convertRelativeUrlToAbsolute(url) {
+    return new URL(url, this.url.toString()).toString();
+  }
+  isInternalLink(url) {
+    try {
+      const parsedUrl = new URL(url, this.url.href);
+      if (!["http:", "https:"].includes(parsedUrl.protocol)) {
+        return false;
+      }
+      const baseDomain = this.normalizeDomain(this.url.hostname);
+      const parsedDomain = this.normalizeDomain(parsedUrl.hostname);
+      return parsedDomain === baseDomain;
+    } catch (error) {
+      this.logger.warn(`Error parsing URL: ${url} - ${error}`);
+      return false;
+    }
+  }
+  async fetchWithRetries(url, retries) {
+    for (let attempt = 1; attempt <= retries; attempt++) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      try {
+        this.logger.debug(`Fetching URL (Attempt ${attempt}): ${url}`);
+        const randomUserAgent = new UserAgent().toString();
+        this.logger.info(`Changing User-Agent to: ${randomUserAgent}`);
+        this.header["User-Agent"] = randomUserAgent;
+        const response = await fetch(url, {
+          headers: this.header,
+          signal: controller.signal,
+          redirect: "follow"
+        });
+        clearTimeout(timeoutId);
+        if (response.ok) {
+          this.logger.info(`Successfully fetched URL: ${url}`);
+          return await response.text();
+        }
+        this.logger.warn(`Failed to fetch URL (${response.status}): ${url}`);
+      } catch (error) {
+        if (error.name === "AbortError") {
+          this.logger.warn(`Fetch timed out: ${url}`);
+        } else {
+          this.logger.error(`Error fetching URL: ${url} - ${error}`);
+        }
+      }
+    }
+    return null;
+  }
+  extractLinks(html) {
+    const { JSDOM } = jsdom;
+    const dom = new JSDOM(html);
+    const links = Array.from(dom.window.document.querySelectorAll("a"));
+    const hrefs = links.map((link) => link.href);
+    const internalLinks = hrefs.filter((href) => this.isInternalLink(href));
+    this.logger.debug(
+      `Extracted ${internalLinks.length} internal links from HTML content`
+    );
+    return internalLinks.map((link) => this.convertRelativeUrlToAbsolute(link));
+  }
+  async crawl() {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = /* @__PURE__ */ new Set([this.url.href]);
+    const resultLinks = /* @__PURE__ */ new Set();
+    const assetExtensions = [
+      ".css",
+      ".js",
+      ".png",
+      ".jpg",
+      ".jpeg",
+      ".gif",
+      ".svg",
+      ".ico",
+      ".webp",
+      ".mp4",
+      ".mp3",
+      ".wav",
+      ".avi",
+      ".mov",
+      ".webm",
+      ".pdf",
+      ".doc",
+      ".docx",
+      ".xls",
+      ".xlsx",
+      ".ppt",
+      ".pptx",
+      ".zip",
+      ".rar",
+      ".tar",
+      ".gz"
+    ];
+    const fetchAndExtract = async (currentUrl) => {
+      if (visited.has(currentUrl)) {
+        this.logger.debug(`Skipping already visited URL: ${currentUrl}`);
+        return;
+      }
+      visited.add(currentUrl);
+      this.logger.info(`Visiting URL: ${currentUrl}`);
+      const html = await this.fetchWithRetries(currentUrl, this.retries);
+      if (!html) return;
+      const links = this.extractLinks(html);
+      for (const link of links) {
+        if (assetExtensions.some((ext) => link.endsWith(ext))) {
+          this.logger.debug(`Ignoring asset link: ${link}`);
+          continue;
+        }
+        this.logger.debug(`Found link: ${link}`);
+      }
+      for (const link of links) {
+        if (!visited.has(link) && queue.size < this.depth) {
+          queue.add(link);
+          this.logger.debug(`Added to queue: ${link}`);
+        }
+      }
+      resultLinks.add(currentUrl);
+    };
+    const processBatch = async () => {
+      const batch = Array.from(queue).slice(0, this.concurrency);
+      for (const url of batch) {
+        queue.delete(url);
+      }
+      await Promise.allSettled(batch.map((url) => fetchAndExtract(url)));
+    };
+    this.logger.info(
+      `Starting crawl with depth: ${this.depth}, concurrency: ${this.concurrency}`
+    );
+    while (queue.size > 0 && visited.size < this.depth) {
+      await processBatch();
+    }
+    this.logger.info(
+      `Crawling completed. Total pages visited: ${resultLinks.size}`
+    );
+    return Array.from(resultLinks);
+  }
+};
+
+// src/commands/spider.ts
+var cliLogger = createLogger("CLI");
+var spiderCommand = {
+  command: "spider",
+  describe: "Crawl a website and get an array of URLs which are internal to the website",
+  builder: (yargs2) => {
+    return yargs2.option("url", {
+      alias: "u",
+      type: "string",
+      description: "The URL of the website to scan",
+      demandOption: true,
+      coerce: (url) => {
+        try {
+          new URL(url);
+          return url;
+        } catch (error) {
+          throw new Error(`Invalid URL: ${url}`);
+        }
+      }
+    }).option("depth", {
+      alias: "d",
+      type: "number",
+      description: "The maximum depth to crawl",
+      default: 250,
+      coerce: (depth) => {
+        if (depth < 0) {
+          throw new Error("Depth must be a positive number");
+        }
+        if (depth > 250) {
+          throw new Error("Depth must be less than 250");
+        }
+        return depth;
+      }
+    }).option("output", {
+      alias: "o",
+      type: "string",
+      description: "The output file to write the results to. Must be a JSON file",
+      coerce: (output) => {
+        try {
+          const resolvedPath = path.resolve(output);
+          const parsedPath = path.parse(resolvedPath);
+          if (parsedPath.ext !== ".json") {
+            throw new Error("Output file must be a JSON file");
+          }
+          if (fs.existsSync(resolvedPath)) {
+            throw new Error("Output file already exists");
+          }
+          return resolvedPath;
+        } catch (error) {
+          throw new Error(`Invalid output file: ${output}`);
+        }
+      },
+      default: getDefaultFilePath()
+    }).option("concurrency", {
+      alias: "c",
+      type: "number",
+      description: "The number of concurrent requests to make",
+      default: 10,
+      coerce: (concurrency) => {
+        if (concurrency < 1) {
+          throw new Error("Concurrency must be a positive number");
+        }
+        if (concurrency > 20) {
+          throw new Error("Concurrency must be less than 20");
+        }
+        return concurrency;
+      }
+    }).option("timeout", {
+      alias: "t",
+      type: "number",
+      description: "The timeout for each request in milliseconds",
+      default: 5e3,
+      coerce: (timeout) => {
+        if (timeout < 0) {
+          throw new Error("Timeout must be a positive number");
+        }
+        if (timeout > 25e3) {
+          throw new Error("Timeout must be less than 25,000");
+        }
+        return timeout;
+      }
+    }).option("retries", {
+      alias: "r",
+      type: "number",
+      description: "The number of retries for each request",
+      default: 3,
+      coerce: (retries) => {
+        if (retries < 0) {
+          throw new Error("Retries must be a positive number");
+        }
+        if (retries > 10) {
+          throw new Error("Retries must be less than 10");
+        }
+        return retries;
+      }
+    });
+  },
+  handler: async (args) => {
+    try {
+      const argData = args;
+      const scanner = new SpiderScanner(argData.url, {
+        depth: argData.depth ?? 250,
+        concurrency: argData.concurrency ?? 10,
+        timeout: argData.timeout ?? 5e3,
+        retries: argData.retries ?? 3
+      });
+      cliLogger.info("Starting to crawl website");
+      const results = await scanner.crawl();
+      if (argData.output) {
+        fs.writeFileSync(argData.output, JSON.stringify(results, null, 2));
+        cliLogger.info(`Results written to ${argData.output}`);
+      } else {
+        const resolvedPath = getDefaultFilePath();
+        fs.writeFileSync(resolvedPath, JSON.stringify(results, null, 2));
+        cliLogger.info(`Results written to ${resolvedPath}`);
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        cliLogger.error(error.message);
+      }
+      cliLogger.error("Failed to run spider command");
+      process.exit(1);
+    }
+  }
+};
+var getDefaultFilePath = () => {
+  try {
+    const resolvedDir = path.resolve("sentinel_output");
+    if (!fs.existsSync(resolvedDir)) {
+      fs.mkdirSync(resolvedDir);
+    }
+    const resolvedPath = path.resolve(
+      `sentinel_output/spider_${Date.now()}.json`
+    );
+    if (fs.existsSync(resolvedPath)) {
+      throw new Error("Output file already exists");
+    }
+    const parsedPath = path.parse(resolvedPath);
+    if (parsedPath.ext !== ".json") {
+      throw new Error("Output file must be a JSON file");
+    }
+    return resolvedPath;
+  } catch (error) {
+    throw new Error("Invalid output file");
+  }
+};
+
+// src/bin.ts
+var commandHandler = yargs(hideBin(process.argv));
+commandHandler.demandCommand();
+commandHandler.scriptName("sentinel-scanner");
+commandHandler.usage("Usage: $0 <command> [options]");
+commandHandler.help().alias("help", "h");
+commandHandler.version().alias("version", "v");
+commandHandler.strict();
+commandHandler.showHelpOnFail(true);
+commandHandler.command(spiderCommand);
+commandHandler.parse();
+//# sourceMappingURL=bin.js.map