kramscan 0.1.0

package/dist/commands/doctor.js

@@ -0,0 +1,234 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDoctorCommand = registerDoctorCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../core/config");
+const logger_1 = require("../utils/logger");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+function registerDoctorCommand(program) {
+    program
+        .command("doctor")
+        .description("Check environment health and configuration")
+        .action(async () => {
+        console.log("");
+        console.log(chalk_1.default.bold.cyan("🩺 KramScan Health Check"));
+        console.log(chalk_1.default.gray("─".repeat(50)));
+        console.log("");
+        const checks = [];
+        // Check Node.js version
+        checks.push(await checkNodeVersion());
+        // Check Puppeteer/Chrome
+        checks.push(await checkPuppeteer());
+        // Check config file
+        checks.push(await checkConfig());
+        // Check API keys
+        checks.push(await checkAPIKeys());
+        // Check disk space
+        checks.push(await checkDiskSpace());
+        // Check network connectivity
+        checks.push(await checkNetwork());
+        // Display results
+        let passCount = 0;
+        let failCount = 0;
+        let warnCount = 0;
+        for (const check of checks) {
+            const icon = check.status === "pass"
+                ? chalk_1.default.green("✓")
+                : check.status === "fail"
+                    ? chalk_1.default.red("✗")
+                    : chalk_1.default.yellow("⚠");
+            console.log(`${icon} ${chalk_1.default.bold(check.name)}`);
+            console.log(`  ${chalk_1.default.gray(check.message)}`);
+            console.log("");
+            if (check.status === "pass")
+                passCount++;
+            else if (check.status === "fail")
+                failCount++;
+            else
+                warnCount++;
+        }
+        // Summary
+        console.log(chalk_1.default.gray("─".repeat(50)));
+        console.log(`${chalk_1.default.green(`${passCount} passed`)} | ${chalk_1.default.yellow(`${warnCount} warnings`)} | ${chalk_1.default.red(`${failCount} failed`)}`);
+        console.log("");
+        if (failCount > 0) {
+            logger_1.logger.error("Some checks failed. Please fix the issues above.");
+            process.exit(1);
+        }
+        else if (warnCount > 0) {
+            logger_1.logger.warn("Some checks have warnings. KramScan should work but may have limitations.");
+        }
+        else {
+            logger_1.logger.success("All checks passed! KramScan is ready to use.");
+        }
+    });
+}
+async function checkNodeVersion() {
+    const version = process.version;
+    const major = parseInt(version.slice(1).split(".")[0]);
+    if (major >= 18) {
+        return {
+            name: "Node.js Version",
+            status: "pass",
+            message: `${version} (>= 18 required)`,
+        };
+    }
+    else {
+        return {
+            name: "Node.js Version",
+            status: "fail",
+            message: `${version} - Please upgrade to Node.js 18 or higher`,
+        };
+    }
+}
+async function checkPuppeteer() {
+    try {
+        const puppeteer = await Promise.resolve().then(() => __importStar(require("puppeteer")));
+        return {
+            name: "Puppeteer",
+            status: "pass",
+            message: "Installed and ready",
+        };
+    }
+    catch (error) {
+        return {
+            name: "Puppeteer",
+            status: "fail",
+            message: "Not installed. Run: npm install puppeteer",
+        };
+    }
+}
+async function checkConfig() {
+    try {
+        const config = (0, config_1.getConfig)();
+        return {
+            name: "Configuration",
+            status: "pass",
+            message: `Config loaded from ~/.kramscan/config.json`,
+        };
+    }
+    catch (error) {
+        return {
+            name: "Configuration",
+            status: "warn",
+            message: "Config file not found. Run 'kramscan onboard' to create it.",
+        };
+    }
+}
+async function checkAPIKeys() {
+    try {
+        const config = (0, config_1.getConfig)();
+        if (!config.ai.enabled) {
+            return {
+                name: "AI Configuration",
+                status: "warn",
+                message: "AI analysis is disabled. Run 'kramscan onboard' to enable it.",
+            };
+        }
+        if (!config.ai.apiKey) {
+            return {
+                name: "AI Configuration",
+                status: "warn",
+                message: `${config.ai.provider} API key not configured. Run 'kramscan onboard' to set it.`,
+            };
+        }
+        return {
+            name: "AI Configuration",
+            status: "pass",
+            message: `${config.ai.provider} configured with model ${config.ai.defaultModel}`,
+        };
+    }
+    catch (error) {
+        return {
+            name: "AI Configuration",
+            status: "warn",
+            message: "Unable to check AI configuration",
+        };
+    }
+}
+async function checkDiskSpace() {
+    try {
+        const homeDir = os_1.default.homedir();
+        const kramScanDir = `${homeDir}/.kramscan`;
+        // Create directory if it doesn't exist
+        await promises_1.default.mkdir(kramScanDir, { recursive: true });
+        return {
+            name: "Disk Space",
+            status: "pass",
+            message: `Scan directory: ${kramScanDir}`,
+        };
+    }
+    catch (error) {
+        return {
+            name: "Disk Space",
+            status: "fail",
+            message: "Unable to access scan directory",
+        };
+    }
+}
+async function checkNetwork() {
+    try {
+        // Simple DNS check
+        const { exec } = require("child_process");
+        await new Promise((resolve, reject) => {
+            exec("ping -n 1 8.8.8.8", (error) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(true);
+            });
+        });
+        return {
+            name: "Network Connectivity",
+            status: "pass",
+            message: "Internet connection available",
+        };
+    }
+    catch (error) {
+        return {
+            name: "Network Connectivity",
+            status: "warn",
+            message: "Unable to verify internet connection",
+        };
+    }
+}

package/dist/commands/onboard.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerOnboardCommand(program: Command): void;

package/dist/commands/onboard.js

@@ -0,0 +1,146 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerOnboardCommand = registerOnboardCommand;
+const readline = __importStar(require("readline"));
+const config_1 = require("../core/config");
+const logger_1 = require("../core/logger");
+// ─── ANSI Helpers ──────────────────────────────────────────────────
+const c = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    cyan: "\x1b[36m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    gray: "\x1b[90m",
+    white: "\x1b[37m",
+    brightCyan: "\x1b[96m",
+};
+// ─── Prompt Utilities ──────────────────────────────────────────────
+function ask(rl, question, defaultVal) {
+    const defaultHint = defaultVal ? ` ${c.gray}(${defaultVal})${c.reset}` : "";
+    return new Promise((resolve) => {
+        rl.question(`  ${c.cyan}?${c.reset} ${question}${defaultHint} `, (answer) => {
+            resolve(answer.trim() || defaultVal || "");
+        });
+    });
+}
+function askConfirm(rl, question, defaultVal = true) {
+    const hint = defaultVal ? `${c.gray}(Y/n)${c.reset}` : `${c.gray}(y/N)${c.reset}`;
+    return new Promise((resolve) => {
+        rl.question(`  ${c.cyan}?${c.reset} ${question} ${hint} `, (answer) => {
+            const a = answer.trim().toLowerCase();
+            if (a === "")
+                resolve(defaultVal);
+            else
+                resolve(a === "y" || a === "yes");
+        });
+    });
+}
+function askList(rl, question, choices, defaultVal) {
+    const choicesStr = choices
+        .map((ch, i) => {
+        const isDefault = ch === defaultVal;
+        return `    ${isDefault ? c.brightCyan + "❯" : " "} ${ch}${c.reset}`;
+    })
+        .join("\n");
+    return new Promise((resolve) => {
+        console.log(`  ${c.cyan}?${c.reset} ${question}`);
+        console.log(choicesStr);
+        rl.question(`  ${c.gray}Enter choice:${c.reset} `, (answer) => {
+            const trimmed = answer.trim();
+            if (choices.includes(trimmed)) {
+                resolve(trimmed);
+            }
+            else {
+                resolve(defaultVal || choices[0]);
+            }
+        });
+    });
+}
+function askPassword(rl, question) {
+    return new Promise((resolve) => {
+        rl.question(`  ${c.cyan}?${c.reset} ${question} ${c.gray}(hidden)${c.reset} `, (answer) => {
+            resolve(answer.trim());
+        });
+    });
+}
+// ─── Command Registration ─────────────────────────────────────────
+function registerOnboardCommand(program) {
+    program
+        .command("onboard")
+        .description("First-time setup wizard")
+        .action(async () => {
+        const logger = (0, logger_1.createLogger)();
+        const store = (0, config_1.getConfigStore)();
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        console.log("");
+        console.log(`  ${c.bold}${c.brightCyan}━━━ KramScan Setup Wizard ━━━${c.reset}`);
+        console.log(`  ${c.gray}Configure your scanning environment${c.reset}`);
+        console.log("");
+        // AI Configuration
+        const aiEnabled = await askConfirm(rl, "Enable AI analysis?", false);
+        store.set("ai.enabled", aiEnabled);
+        if (aiEnabled) {
+            const aiProvider = await askList(rl, "Select AI provider", ["openai", "anthropic"], "openai");
+            store.set("ai.provider", aiProvider);
+            const apiKey = await askPassword(rl, "API key (leave blank to skip)");
+            if (apiKey) {
+                store.set("ai.apiKey", apiKey);
+            }
+            const model = await ask(rl, "Default AI model", aiProvider === "openai" ? "gpt-4" : "claude-3-opus-20240229");
+            store.set("ai.model", model);
+        }
+        // Report Configuration
+        const reportFormat = await askList(rl, "Default report format", ["word", "txt", "json"], "word");
+        store.set("report.defaultFormat", reportFormat);
+        // Scan Configuration
+        const strictScope = await askConfirm(rl, "Enable strict scope enforcement?", true);
+        store.set("scan.strictScope", strictScope);
+        const rateLimitStr = await ask(rl, "Requests per second rate limit", "5");
+        const rateLimit = parseInt(rateLimitStr, 10) || 5;
+        store.set("scan.rateLimitPerSecond", rateLimit);
+        rl.close();
+        console.log("");
+        logger.success("Onboarding complete! Your configuration has been saved.");
+        console.log(`  ${c.gray}Config location: ~/.kramscan/config.json${c.reset}`);
+        console.log(`  ${c.gray}Run ${c.cyan}kramscan${c.gray} to get started.${c.reset}`);
+        console.log("");
+    });
+}

package/dist/commands/report.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerReportCommand(program: Command): void;

package/dist/commands/report.js

@@ -0,0 +1,225 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerReportCommand = registerReportCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const logger_1 = require("../utils/logger");
+const config_1 = require("../core/config");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const docx_1 = require("docx");
+function registerReportCommand(program) {
+    program
+        .command("report [scan-file]")
+        .description("Generate a professional security report")
+        .option("-f, --format <type>", "Report format: word|json|txt")
+        .option("-o, --output <file>", "Output filename")
+        .action(async (scanFile, options) => {
+        console.log("");
+        console.log(chalk_1.default.bold.cyan("📄 Generating Security Report"));
+        console.log(chalk_1.default.gray("─".repeat(50)));
+        console.log("");
+        try {
+            // Load scan results
+            let filepath;
+            if (scanFile) {
+                filepath = path_1.default.isAbsolute(scanFile)
+                    ? scanFile
+                    : path_1.default.join(process.cwd(), scanFile);
+            }
+            else {
+                // Find latest scan
+                const scanDir = path_1.default.join(os_1.default.homedir(), ".kramscan", "scans");
+                const files = await promises_1.default.readdir(scanDir);
+                const scanFiles = files.filter((f) => f.endsWith(".json"));
+                if (scanFiles.length === 0) {
+                    logger_1.logger.error("No scan results found. Run 'kramscan scan <url>' first.");
+                    process.exit(1);
+                }
+                scanFiles.sort().reverse();
+                filepath = path_1.default.join(scanDir, scanFiles[0]);
+                logger_1.logger.info(`Using latest scan: ${scanFiles[0]}`);
+            }
+            const content = await promises_1.default.readFile(filepath, "utf-8");
+            const scanResult = JSON.parse(content);
+            // Determine format
+            const config = (0, config_1.getConfig)();
+            const format = options.format || config.report.defaultFormat;
+            const spinner = logger_1.logger.spinner(`Generating ${format.toUpperCase()} report...`);
+            let outputPath;
+            switch (format) {
+                case "word":
+                    outputPath = await generateWordReport(scanResult, options.output);
+                    break;
+                case "json":
+                    outputPath = await generateJsonReport(scanResult, options.output);
+                    break;
+                case "txt":
+                    outputPath = await generateTxtReport(scanResult, options.output);
+                    break;
+                default:
+                    throw new Error(`Unsupported format: ${format}`);
+            }
+            spinner.succeed("Report generated!");
+            console.log("");
+            logger_1.logger.success(`Report saved to: ${outputPath}`);
+            console.log("");
+        }
+        catch (error) {
+            logger_1.logger.error(error.message);
+            process.exit(1);
+        }
+    });
+}
+async function generateWordReport(scanResult, outputFile) {
+    const doc = new docx_1.Document({
+        sections: [
+            {
+                properties: {},
+                children: [
+                    // Title
+                    new docx_1.Paragraph({
+                        text: "Security Assessment Report",
+                        heading: docx_1.HeadingLevel.HEADING_1,
+                        alignment: docx_1.AlignmentType.CENTER,
+                    }),
+                    new docx_1.Paragraph({
+                        text: `Target: ${scanResult.target}`,
+                        alignment: docx_1.AlignmentType.CENTER,
+                    }),
+                    new docx_1.Paragraph({
+                        text: `Date: ${new Date(scanResult.timestamp).toLocaleString()}`,
+                        alignment: docx_1.AlignmentType.CENTER,
+                    }),
+                    new docx_1.Paragraph({ text: "" }),
+                    // Executive Summary
+                    new docx_1.Paragraph({
+                        text: "Executive Summary",
+                        heading: docx_1.HeadingLevel.HEADING_2,
+                    }),
+                    new docx_1.Paragraph({
+                        children: [
+                            new docx_1.TextRun({
+                                text: `This report contains the results of an automated security assessment performed on ${scanResult.target}. `,
+                            }),
+                            new docx_1.TextRun({
+                                text: `A total of ${scanResult.summary.total} vulnerabilities were identified, `,
+                            }),
+                            new docx_1.TextRun({
+                                text: `including ${scanResult.summary.critical} critical and ${scanResult.summary.high} high severity issues.`,
+                            }),
+                        ],
+                    }),
+                    new docx_1.Paragraph({ text: "" }),
+                    // Scan Statistics
+                    new docx_1.Paragraph({
+                        text: "Scan Statistics",
+                        heading: docx_1.HeadingLevel.HEADING_2,
+                    }),
+                    new docx_1.Paragraph({ text: `• URLs Crawled: ${scanResult.metadata.crawledUrls}` }),
+                    new docx_1.Paragraph({ text: `• Forms Tested: ${scanResult.metadata.testedForms}` }),
+                    new docx_1.Paragraph({ text: `• Requests Made: ${scanResult.metadata.requestsMade}` }),
+                    new docx_1.Paragraph({
+                        text: `• Duration: ${(scanResult.duration / 1000).toFixed(2)} seconds`,
+                    }),
+                    new docx_1.Paragraph({ text: "" }),
+                    // Findings
+                    new docx_1.Paragraph({
+                        text: "Detailed Findings",
+                        heading: docx_1.HeadingLevel.HEADING_2,
+                    }),
+                    ...scanResult.vulnerabilities.flatMap((vuln, i) => [
+                        new docx_1.Paragraph({
+                            text: `${i + 1}. ${vuln.title} [${vuln.severity.toUpperCase()}]`,
+                            heading: docx_1.HeadingLevel.HEADING_3,
+                        }),
+                        new docx_1.Paragraph({ text: `URL: ${vuln.url}` }),
+                        new docx_1.Paragraph({ text: `Type: ${vuln.type}` }),
+                        new docx_1.Paragraph({ text: `Description: ${vuln.description}` }),
+                        ...(vuln.evidence
+                            ? [new docx_1.Paragraph({ text: `Evidence: ${vuln.evidence}` })]
+                            : []),
+                        ...(vuln.remediation
+                            ? [new docx_1.Paragraph({ text: `Remediation: ${vuln.remediation}` })]
+                            : []),
+                        ...(vuln.cwe ? [new docx_1.Paragraph({ text: `CWE: ${vuln.cwe}` })] : []),
+                        new docx_1.Paragraph({ text: "" }),
+                    ]),
+                ],
+            },
+        ],
+    });
+    const buffer = await docx_1.Packer.toBuffer(doc);
+    const reportsDir = path_1.default.join(os_1.default.homedir(), ".kramscan", "reports");
+    await promises_1.default.mkdir(reportsDir, { recursive: true });
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const filename = outputFile || `report-${timestamp}.docx`;
+    const filepath = path_1.default.isAbsolute(filename)
+        ? filename
+        : path_1.default.join(reportsDir, filename);
+    await promises_1.default.writeFile(filepath, buffer);
+    return filepath;
+}
+async function generateJsonReport(scanResult, outputFile) {
+    const reportsDir = path_1.default.join(os_1.default.homedir(), ".kramscan", "reports");
+    await promises_1.default.mkdir(reportsDir, { recursive: true });
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const filename = outputFile || `report-${timestamp}.json`;
+    const filepath = path_1.default.isAbsolute(filename)
+        ? filename
+        : path_1.default.join(reportsDir, filename);
+    await promises_1.default.writeFile(filepath, JSON.stringify(scanResult, null, 2));
+    return filepath;
+}
+async function generateTxtReport(scanResult, outputFile) {
+    const lines = [];
+    lines.push("=".repeat(60));
+    lines.push("SECURITY ASSESSMENT REPORT");
+    lines.push("=".repeat(60));
+    lines.push("");
+    lines.push(`Target: ${scanResult.target}`);
+    lines.push(`Date: ${new Date(scanResult.timestamp).toLocaleString()}`);
+    lines.push(`Duration: ${(scanResult.duration / 1000).toFixed(2)}s`);
+    lines.push("");
+    lines.push("EXECUTIVE SUMMARY");
+    lines.push("-".repeat(60));
+    lines.push(`Total Vulnerabilities: ${scanResult.summary.total} (${scanResult.summary.critical} Critical, ${scanResult.summary.high} High, ${scanResult.summary.medium} Medium, ${scanResult.summary.low} Low, ${scanResult.summary.info} Info)`);
+    lines.push("");
+    lines.push("SCAN STATISTICS");
+    lines.push("-".repeat(60));
+    lines.push(`URLs Crawled: ${scanResult.metadata.crawledUrls}`);
+    lines.push(`Forms Tested: ${scanResult.metadata.testedForms}`);
+    lines.push(`Requests Made: ${scanResult.metadata.requestsMade}`);
+    lines.push("");
+    lines.push("DETAILED FINDINGS");
+    lines.push("-".repeat(60));
+    lines.push("");
+    scanResult.vulnerabilities.forEach((vuln, i) => {
+        lines.push(`${i + 1}. ${vuln.title} [${vuln.severity.toUpperCase()}]`);
+        lines.push(`   URL: ${vuln.url}`);
+        lines.push(`   Type: ${vuln.type}`);
+        lines.push(`   Description: ${vuln.description}`);
+        if (vuln.evidence)
+            lines.push(`   Evidence: ${vuln.evidence}`);
+        if (vuln.remediation)
+            lines.push(`   Remediation: ${vuln.remediation}`);
+        if (vuln.cwe)
+            lines.push(`   CWE: ${vuln.cwe}`);
+        lines.push("");
+    });
+    lines.push("=".repeat(60));
+    lines.push("End of Report");
+    lines.push("=".repeat(60));
+    const reportsDir = path_1.default.join(os_1.default.homedir(), ".kramscan", "reports");
+    await promises_1.default.mkdir(reportsDir, { recursive: true });
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const filename = outputFile || `report-${timestamp}.txt`;
+    const filepath = path_1.default.isAbsolute(filename)
+        ? filename
+        : path_1.default.join(reportsDir, filename);
+    await promises_1.default.writeFile(filepath, lines.join("\n"));
+    return filepath;
+}

package/dist/commands/scan.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerScanCommand(program: Command): void;