recker 1.0.43 → 1.0.44

package/dist/cli/commands/protocols.js

@@ -0,0 +1,344 @@
+import colors from '../../utils/colors.js';
+import { RekArgs, generateHelp } from '../parser/index.js';
+import { promises as fs } from 'node:fs';
+import pathMod from 'node:path';
+const ftpSchema = {
+    name: 'ftp',
+    description: 'FTP client operations',
+    params: {
+        user: { type: 'string', default: 'anonymous', description: 'Username' },
+        pass: { type: 'string', default: 'anonymous@', description: 'Password' },
+        port: { type: 'number', default: 21, description: 'Port' },
+    },
+    flags: {
+        secure: { description: 'Use FTPS (explicit TLS)', default: false },
+        implicit: { description: 'Use implicit FTPS (port 990)', default: false }
+    },
+    examples: [
+        { cmd: 'rek ftp ls ftp.example.com', desc: 'List files' },
+        { cmd: 'rek ftp get ftp.example.com /file.txt', desc: 'Download file' }
+    ]
+};
+const telnetSchema = {
+    name: 'telnet',
+    description: 'Connect to a Telnet server',
+    params: {
+        timeout: { type: 'number', default: 30000, description: 'Timeout in ms' }
+    },
+    examples: [
+        { cmd: 'rek telnet towel.blinkenlights.nl', desc: 'Star Wars' },
+        { cmd: 'rek telnet localhost 23', desc: 'Local server' }
+    ]
+};
+const graphqlSchema = {
+    name: 'graphql',
+    description: 'Execute GraphQL queries and mutations',
+    params: {
+        query: { type: 'string', description: 'Inline query' },
+        file: { type: 'string', description: 'Query file path' },
+        variables: { type: 'json', description: 'Variables JSON' },
+        'var-file': { type: 'string', description: 'Variables file path' }
+    },
+    examples: [
+        { cmd: 'rek graphql api.com/graphql query="{ me { name } }"', desc: 'Simple query' }
+    ]
+};
+const jsonRpcSchema = {
+    name: 'jsonrpc',
+    description: 'Make JSON-RPC 2.0 calls',
+    params: {
+        method: { type: 'string', description: 'RPC Method' },
+        params: { type: 'json', description: 'RPC Params (array or object)' }
+    },
+    examples: [
+        { cmd: 'rek jsonrpc api.com/rpc method=sum params=[1,2]', desc: 'Call method' }
+    ]
+};
+const soapSchema = {
+    name: 'soap',
+    description: 'Make a SOAP request',
+    params: {
+        namespace: { type: 'string', description: 'SOAP namespace' },
+        envelope: { type: 'string', default: '1.1', description: 'SOAP envelope version' },
+    },
+    examples: [
+        { cmd: 'rek soap api.com/ws GetWeather city="New York"', desc: 'SOAP Action' }
+    ]
+};
+const odataSchema = {
+    name: 'odata',
+    description: 'Query an OData service',
+    params: {
+        select: { type: 'string', description: 'Select fields' },
+        filter: { type: 'string', description: 'Filter expression' },
+        orderby: { type: 'string', description: 'Order by' },
+        top: { type: 'number', description: 'Limit results' },
+        skip: { type: 'number', description: 'Skip results' },
+        expand: { type: 'string', description: 'Expand navigation' },
+    },
+    examples: [
+        { cmd: 'rek odata api.com/odata Customers top=10', desc: 'Query' }
+    ]
+};
+export function registerProtocolCommands(program) {
+    const ftpCmd = program.command('ftp')
+        .description('FTP client operations')
+        .addHelpText('after', generateHelp(ftpSchema));
+    ftpCmd.command('ls')
+        .description('List files')
+        .argument('<host>', 'FTP Host')
+        .argument('[args...]', 'Path and options')
+        .action(async (host, rawArgs) => {
+        const { data, args } = RekArgs.parse(rawArgs, ftpSchema);
+        const path = args[0] || '/';
+        const secure = data.implicit ? 'implicit' : !!data.secure;
+        const { createFTP } = await import('../../protocols/ftp.js');
+        const client = createFTP({ host, port: data.port, user: data.user, password: data.pass, secure });
+        console.log(colors.gray(`Connecting to ${host}...`));
+        try {
+            const connectResult = await client.connect();
+            if (!connectResult.success)
+                throw new Error(connectResult.message);
+            console.log(colors.green('Connected'));
+            const result = await client.list(path);
+            if (!result.success || !result.data)
+                throw new Error(result.message);
+            console.log(`\n${colors.bold(`Contents of ${path}:`)}\n`);
+            for (const item of result.data) {
+                const typeChar = item.type === 'directory' ? 'd' : item.type === 'link' ? 'l' : '-';
+                const nameColor = item.type === 'directory' ? colors.blue : colors.white;
+                console.log(`${typeChar}${item.permissions || 'rwxr-xr-x'}  ${item.size.toString().padStart(10)}  ${item.rawModifiedAt || ''}  ${nameColor(item.name)}`);
+            }
+            await client.close();
+        }
+        catch (err) {
+            console.error(colors.red(`FTP Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    ftpCmd.command('get')
+        .description('Download file')
+        .argument('<host>', 'FTP Host')
+        .argument('<remote>', 'Remote path')
+        .argument('[args...]', 'Local path and options')
+        .action(async (host, remote, rawArgs) => {
+        const { data, args } = RekArgs.parse(rawArgs, ftpSchema);
+        const local = args[0] || pathMod.basename(remote);
+        const secure = data.implicit ? 'implicit' : !!data.secure;
+        const { createFTP } = await import('../../protocols/ftp.js');
+        const client = createFTP({ host, port: data.port, user: data.user, password: data.pass, secure });
+        console.log(colors.gray(`Connecting to ${host}...`));
+        try {
+            if (!(await client.connect()).success)
+                throw new Error('Connection failed');
+            console.log(colors.gray(`Downloading ${remote} -> ${local}...`));
+            let lastProgress = 0;
+            client.progress((p) => {
+                if (p.bytesOverall - lastProgress > 100000) {
+                    process.stdout.write(`\r  ${colors.cyan((p.bytesOverall / 1024 / 1024).toFixed(2) + ' MB')} downloaded...`);
+                    lastProgress = p.bytesOverall;
+                }
+            });
+            const result = await client.download(remote, local);
+            console.log('');
+            if (!result.success)
+                throw new Error(result.message);
+            console.log(colors.green(`✔ Downloaded to ${local}`));
+            await client.close();
+        }
+        catch (err) {
+            console.error(colors.red(`FTP Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    ftpCmd.command('put')
+        .description('Upload file')
+        .argument('<host>', 'FTP Host')
+        .argument('<local>', 'Local path')
+        .argument('[args...]', 'Remote path and options')
+        .action(async (host, local, rawArgs) => {
+        const { data, args } = RekArgs.parse(rawArgs, ftpSchema);
+        const remote = args[0] || '/' + pathMod.basename(local);
+        const secure = data.implicit ? 'implicit' : !!data.secure;
+        const { createFTP } = await import('../../protocols/ftp.js');
+        const client = createFTP({ host, port: data.port, user: data.user, password: data.pass, secure });
+        console.log(colors.gray(`Connecting to ${host}...`));
+        try {
+            if (!(await client.connect()).success)
+                throw new Error('Connection failed');
+            console.log(colors.gray(`Uploading ${local} -> ${remote}...`));
+            let lastProgress = 0;
+            client.progress((p) => {
+                if (p.bytesOverall - lastProgress > 100000) {
+                    process.stdout.write(`\r  ${colors.cyan((p.bytesOverall / 1024 / 1024).toFixed(2) + ' MB')} uploaded...`);
+                    lastProgress = p.bytesOverall;
+                }
+            });
+            const result = await client.upload(local, remote);
+            console.log('');
+            if (!result.success)
+                throw new Error(result.message);
+            console.log(colors.green(`✔ Uploaded to ${remote}`));
+            await client.close();
+        }
+        catch (err) {
+            console.error(colors.red(`FTP Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    program.command('telnet')
+        .description(telnetSchema.description)
+        .argument('<host>', 'Hostname')
+        .argument('[args...]', 'Port and options')
+        .addHelpText('after', generateHelp(telnetSchema))
+        .action(async (host, rawArgs) => {
+        const { data, args } = RekArgs.parse(rawArgs, telnetSchema);
+        let port = 23;
+        if (args.length > 0)
+            port = parseInt(String(args[0]));
+        const { createTelnet } = await import('../../protocols/telnet.js');
+        console.log(colors.gray(`Connecting to ${host}:${port}...`));
+        const client = createTelnet({ host, port, timeout: data.timeout });
+        try {
+            await client.connect();
+            console.log(colors.green(`Connected to ${host}:${port}`));
+            if (process.stdin.isTTY)
+                process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.on('data', async (d) => {
+                if (d[0] === 0x03) {
+                    await client.close();
+                    process.exit(0);
+                }
+                await client.send(d.toString());
+            });
+            client.on('data', (d) => process.stdout.write(d));
+            client.on('close', () => process.exit(0));
+            client.on('error', (e) => { console.error(colors.red(e.message)); process.exit(1); });
+        }
+        catch (err) {
+            console.error(colors.red(`Telnet Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    program.command('graphql').alias('gql')
+        .description(graphqlSchema.description)
+        .argument('<url>', 'GraphQL Endpoint')
+        .argument('[args...]', 'Options')
+        .addHelpText('after', generateHelp(graphqlSchema))
+        .action(async (url, rawArgs) => {
+        const { data, headers } = RekArgs.parse(rawArgs, graphqlSchema);
+        let query = data.query;
+        let variables = data.variables || {};
+        if (data.file)
+            query = await fs.readFile(data.file, 'utf-8');
+        if (data['var-file'])
+            variables = JSON.parse(await fs.readFile(data['var-file'], 'utf-8'));
+        if (!query) {
+            console.error(colors.red('Error: Query is required via query= or file='));
+            process.exit(1);
+        }
+        if (!url.startsWith('http'))
+            url = `https://${url}`;
+        const { graphql } = await import('../../plugins/graphql.js');
+        const { createClient } = await import('../../core/client.js');
+        try {
+            const client = createClient({ baseUrl: url, headers: { 'Content-Type': 'application/json', ...headers } });
+            const result = await graphql(client, query, variables);
+            console.log(JSON.stringify(result, null, 2));
+        }
+        catch (err) {
+            console.error(colors.red(`GraphQL Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    program.command('jsonrpc')
+        .description(jsonRpcSchema.description)
+        .argument('<url>', 'Endpoint')
+        .argument('<method>', 'Method')
+        .argument('[args...]', 'Params and options')
+        .addHelpText('after', generateHelp(jsonRpcSchema))
+        .action(async (url, method, rawArgs) => {
+        const { data, headers, args } = RekArgs.parse(rawArgs, jsonRpcSchema);
+        let params = data.params;
+        if (!params && args.length > 0) {
+            params = args;
+        }
+        if (!url.startsWith('http'))
+            url = `https://${url}`;
+        const { createJsonRpcClient } = await import('../../plugins/jsonrpc.js');
+        const { createClient } = await import('../../core/client.js');
+        try {
+            const client = createClient({ baseUrl: url, headers });
+            const rpc = createJsonRpcClient(client, { endpoint: url });
+            const result = await rpc.call(method, params);
+            console.log(JSON.stringify(result, null, 2));
+        }
+        catch (err) {
+            console.error(colors.red(`RPC Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    program.command('soap')
+        .description(soapSchema.description)
+        .argument('<url>', 'SOAP Endpoint')
+        .argument('<action>', 'Action/Operation')
+        .argument('[args...]', 'Parameters')
+        .addHelpText('after', generateHelp(soapSchema))
+        .action(async (url, action, rawArgs) => {
+        const { data, headers } = RekArgs.parse(rawArgs, soapSchema);
+        if (!url.startsWith('http'))
+            url = `https://${url}`;
+        const { createClient } = await import('../../core/client.js');
+        const { createSoapClient } = await import('../../plugins/soap.js');
+        try {
+            const httpClient = createClient({ headers });
+            const soap = createSoapClient(httpClient, { endpoint: url, namespace: data.namespace });
+            const body = { ...data };
+            delete body.namespace;
+            delete body.envelope;
+            const result = await soap.call(action, body);
+            console.log(JSON.stringify(result, null, 2));
+        }
+        catch (err) {
+            console.error(colors.red(`SOAP Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    program.command('odata')
+        .description(odataSchema.description)
+        .argument('<url>', 'OData Service URL')
+        .argument('<entity>', 'Entity Set')
+        .argument('[args...]', 'Query Options')
+        .addHelpText('after', generateHelp(odataSchema))
+        .action(async (url, entity, rawArgs) => {
+        const { data, headers } = RekArgs.parse(rawArgs, odataSchema);
+        if (!url.startsWith('http'))
+            url = `https://${url}`;
+        const { createClient } = await import('../../core/client.js');
+        const { createODataClient } = await import('../../plugins/odata.js');
+        try {
+            const httpClient = createClient({ headers });
+            const odata = createODataClient(httpClient, { serviceRoot: url });
+            let query = odata.query(entity);
+            if (data.select)
+                query = query.select(...data.select.split(','));
+            if (data.filter)
+                query = query.filter(data.filter);
+            if (data.orderby)
+                query = query.orderBy(data.orderby);
+            if (data.top)
+                query = query.top(data.top);
+            if (data.skip)
+                query = query.skip(data.skip);
+            if (data.expand)
+                query = query.expand(data.expand);
+            const results = await query.get();
+            console.log(JSON.stringify(results, null, 2));
+        }
+        catch (err) {
+            console.error(colors.red(`OData Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+}

package/dist/cli/commands/scrape.d.ts

@@ -0,0 +1,2 @@
+import { RekCommand as Command } from '../router.js';
+export declare function registerScrapeCommand(program: Command): void;

package/dist/cli/commands/scrape.js

@@ -0,0 +1,176 @@
+import colors from '../../utils/colors.js';
+import { RekArgs, generateHelp } from '../parser/index.js';
+const schema = {
+    name: 'scrape',
+    description: 'Extract data from web pages with CSS selectors.\nFetches a web page and extracts data using CSS selectors or built-in extractors.',
+    params: {
+        select: { type: 'string', description: 'CSS selector to extract elements' },
+        attr: { type: 'string', description: 'Extract specific attribute (use with select)' },
+    },
+    keywords: {
+        links: { description: 'Extract all links with text and href' },
+        images: { description: 'Extract all images with src and alt' },
+        meta: { description: 'Extract all meta tags' },
+        tables: { description: 'Extract tables as structured JSON' },
+        scripts: { description: 'Extract all script sources' },
+        jsonld: { description: 'Extract JSON-LD structured data' },
+    },
+    examples: [
+        { cmd: 'rek scrape example.com', desc: 'Basic page info' },
+        { cmd: 'rek scrape example.com select="h1"', desc: 'Extract h1 text' },
+        { cmd: 'rek scrape example.com select="a" attr=href', desc: 'Extract link hrefs' },
+        { cmd: 'rek scrape example.com links', desc: 'All links' },
+        { cmd: 'rek scrape example.com tables', desc: 'All tables as JSON' }
+    ]
+};
+export function registerScrapeCommand(program) {
+    program
+        .command('scrape')
+        .alias('extract')
+        .description('Extract data from web pages with CSS selectors')
+        .argument('<url>', 'URL to scrape')
+        .argument('[args...]', 'Options: select=SELECTOR, attr=NAME, links, images...')
+        .addHelpText('after', generateHelp(schema))
+        .action(async (url, rawArgs) => {
+        const { data } = RekArgs.parse(rawArgs, schema);
+        const { ScrapeDocument } = await import('../../scrape/document.js');
+        const { Client } = await import('../../core/client.js');
+        if (!url.startsWith('http://') && !url.startsWith('https://')) {
+            url = `https://${url}`;
+        }
+        console.log(colors.gray(`Fetching ${url}...`));
+        try {
+            const client = new Client();
+            const response = await client.get(url);
+            const html = await response.text();
+            const doc = await ScrapeDocument.create(html, { baseUrl: url });
+            const hasExtraction = data.select || data.links || data.images || data.meta || data.tables || data.scripts || data.jsonld;
+            if (!hasExtraction) {
+                const title = doc.text('title') || 'N/A';
+                const description = doc.attr('meta[name="description"]', 'content') || 'N/A';
+                const h1 = doc.text('h1') || 'N/A';
+                const linkCount = doc.links().length;
+                const imageCount = doc.images().length;
+                console.log(`
+${colors.bold(colors.cyan('📄 Page Info'))}
+
+${colors.bold('Title:')}       ${title}
+${colors.bold('Description:')} ${description.slice(0, 100)}${description.length > 100 ? '...' : ''}
+${colors.bold('H1:')}          ${h1}
+${colors.bold('Links:')}       ${linkCount}
+${colors.bold('Images:')}      ${imageCount}
+`);
+                return;
+            }
+            if (data.select) {
+                if (data.attr) {
+                    const values = doc.attrs(data.select, data.attr);
+                    console.log(`\n${colors.bold(`Found ${values.length} values for "${data.attr}" in "${data.select}"`)}\n`);
+                    values.slice(0, 50).forEach((value, i) => {
+                        if (value) {
+                            console.log(`${colors.gray(`${i + 1}.`)} ${value}`);
+                        }
+                    });
+                    if (values.length > 50) {
+                        console.log(colors.gray(`\n... and ${values.length - 50} more`));
+                    }
+                }
+                else {
+                    const texts = doc.texts(data.select);
+                    console.log(`\n${colors.bold(`Found ${texts.length} elements matching "${data.select}"`)}\n`);
+                    texts.slice(0, 50).forEach((text, i) => {
+                        const trimmed = text.trim();
+                        if (trimmed) {
+                            console.log(`${colors.gray(`${i + 1}.`)} ${trimmed.slice(0, 200)}`);
+                        }
+                    });
+                    if (texts.length > 50) {
+                        console.log(colors.gray(`\n... and ${texts.length - 50} more`));
+                    }
+                }
+                return;
+            }
+            if (data.links) {
+                const links = doc.links();
+                console.log(`\n${colors.bold(`Found ${links.length} links`)}\n`);
+                links.slice(0, 50).forEach((link, i) => {
+                    const text = (link.text || '').trim().slice(0, 50) || '[no text]';
+                    console.log(`${colors.gray(`${i + 1}.`)} ${colors.cyan(text)}`);
+                    console.log(`   ${colors.gray(link.href)}`);
+                });
+                if (links.length > 50) {
+                    console.log(colors.gray(`\n... and ${links.length - 50} more`));
+                }
+                return;
+            }
+            if (data.images) {
+                const images = doc.images();
+                console.log(`\n${colors.bold(`Found ${images.length} images`)}\n`);
+                images.slice(0, 30).forEach((img, i) => {
+                    const alt = img.alt || '[no alt]';
+                    console.log(`${colors.gray(`${i + 1}.`)} ${colors.cyan(alt.slice(0, 50))}`);
+                    console.log(`   ${colors.gray(img.src)}`);
+                });
+                if (images.length > 30) {
+                    console.log(colors.gray(`\n... and ${images.length - 30} more`));
+                }
+                return;
+            }
+            if (data.meta) {
+                const meta = doc.meta();
+                const entries = Object.entries(meta);
+                console.log(`\n${colors.bold(`Found ${entries.length} meta entries`)}\n`);
+                entries.forEach(([name, content]) => {
+                    if (name && content) {
+                        const value = String(content);
+                        console.log(`${colors.cyan(name)}: ${value.slice(0, 100)}${value.length > 100 ? '...' : ''}`);
+                    }
+                });
+                return;
+            }
+            if (data.tables) {
+                const tables = doc.tables();
+                console.log(`\n${colors.bold(`Found ${tables.length} tables`)}\n`);
+                tables.slice(0, 5).forEach((table, tableIndex) => {
+                    console.log(`${colors.bold(`Table ${tableIndex + 1}:`)} ${table.rows?.length || 0} rows`);
+                    console.log(JSON.stringify((table.rows || []).slice(0, 10), null, 2));
+                    if ((table.rows?.length || 0) > 10) {
+                        console.log(colors.gray(`... and ${(table.rows?.length || 0) - 10} more rows`));
+                    }
+                    console.log('');
+                });
+                return;
+            }
+            if (data.scripts) {
+                const scripts = doc.scripts();
+                const external = scripts.filter(s => s.src);
+                const inline = scripts.filter(s => !s.src);
+                console.log(`\n${colors.bold(`Found ${external.length} external scripts, ${inline.length} inline`)}\n`);
+                if (external.length > 0) {
+                    console.log(colors.bold('External Scripts:'));
+                    external.slice(0, 20).forEach((script, i) => {
+                        console.log(`${colors.gray(`${i + 1}.`)} ${script.src}`);
+                    });
+                    if (external.length > 20) {
+                        console.log(colors.gray(`... and ${external.length - 20} more`));
+                    }
+                }
+                return;
+            }
+            if (data.jsonld) {
+                const jsonld = doc.jsonLd();
+                console.log(`\n${colors.bold(`Found ${jsonld.length} JSON-LD blocks`)}\n`);
+                jsonld.forEach((data, i) => {
+                    console.log(`${colors.bold(`Block ${i + 1}:`)} ${data['@type'] || 'Unknown type'}`);
+                    console.log(JSON.stringify(data, null, 2));
+                    console.log('');
+                });
+                return;
+            }
+        }
+        catch (error) {
+            console.error(colors.red(`Scrape failed: ${error.message}`));
+            process.exit(1);
+        }
+    });
+}

package/dist/cli/commands/security.d.ts

@@ -0,0 +1,2 @@
+import { RekCommand as Command } from '../router.js';
+export declare function registerSecurityCommand(program: Command): void;

package/dist/cli/commands/security.js

@@ -0,0 +1,57 @@
+import colors from '../../utils/colors.js';
+import { generateHelp } from '../parser/index.js';
+const schema = {
+    name: 'security',
+    description: 'Grade a website\'s security headers (A+ to F).\nAnalyzes HTTP response headers for security best practices like HSTS, CSP, and more.',
+    examples: [
+        { cmd: 'rek security github.com', desc: 'Grade GitHub\'s headers' }
+    ]
+};
+export function registerSecurityCommand(program) {
+    program
+        .command('security')
+        .alias('headers')
+        .alias('grade')
+        .description('Grade a website\'s security headers')
+        .argument('<url>', 'URL to analyze')
+        .addHelpText('after', generateHelp(schema))
+        .action(async (url) => {
+        if (!url.startsWith('http'))
+            url = `https://${url}`;
+        const { createClient } = await import('../../core/client.js');
+        const { analyzeSecurityHeaders } = await import('../../utils/security-grader.js');
+        console.log(colors.gray(`Analyzing security headers for ${url}...`));
+        try {
+            const origin = new URL(url).origin;
+            const client = createClient({ baseUrl: origin });
+            const res = await client.get(url);
+            const report = analyzeSecurityHeaders(res.headers);
+            let gradeColor = colors.red;
+            if (report.grade.startsWith('A'))
+                gradeColor = colors.green;
+            if (report.grade.startsWith('B'))
+                gradeColor = colors.blue;
+            if (report.grade.startsWith('C'))
+                gradeColor = colors.yellow;
+            console.log(`
+${colors.bold(colors.cyan('🛡️  Security Headers Report'))}
+Grade: ${gradeColor(colors.bold(report.grade))}  (${report.score}/100)
+
+${colors.bold('Details:')}`);
+            report.details.forEach(item => {
+                const icon = item.status === 'pass' ? colors.green('✔') : item.status === 'warn' ? colors.yellow('⚠') : colors.red('✖');
+                const headerName = colors.bold(item.header);
+                const value = item.value ? colors.gray(`= ${item.value.length > 50 ? item.value.slice(0, 47) + '...' : item.value}`) : colors.gray('(missing)');
+                console.log(`  ${icon} ${headerName} ${value}`);
+                if (item.status !== 'pass') {
+                    console.log(`      ${colors.red('→')} ${item.message}`);
+                }
+            });
+            console.log('');
+        }
+        catch (error) {
+            console.error(colors.red(`Analysis failed: ${error.message}`));
+            process.exit(1);
+        }
+    });
+}

package/dist/cli/commands/seo.d.ts

@@ -0,0 +1,2 @@
+import { RekCommand as Command } from '../router.js';
+export declare function registerSeoCommand(program: Command): void;