recker 1.0.43 → 1.0.44

package/dist/cli/parser/help.d.ts

@@ -0,0 +1,2 @@
+import { CommandSchema } from './types.js';
+export declare function generateHelp(schema: CommandSchema): string;

package/dist/cli/parser/help.js

@@ -0,0 +1,52 @@
+import colors from '../../utils/colors.js';
+export function generateHelp(schema) {
+    const lines = [];
+    lines.push('');
+    lines.push(`${colors.bold(colors.blue('What it does:'))}`);
+    const descLines = schema.description.split('\n');
+    descLines.forEach(line => lines.push(`  ${line.trim()}`));
+    lines.push('');
+    if (schema.examples && schema.examples.length > 0) {
+        lines.push(`${colors.bold(colors.yellow('Examples:'))}`);
+        schema.examples.forEach(ex => {
+            const cmdPart = `  $ ${ex.cmd}`;
+            const padding = Math.max(0, 60 - cmdPart.length);
+            const spaces = ' '.repeat(padding);
+            lines.push(`${colors.green(cmdPart)}${spaces}${colors.gray(`# ${ex.desc}`)}`);
+        });
+        lines.push('');
+    }
+    if (schema.params && Object.keys(schema.params).length > 0) {
+        lines.push(`${colors.bold(colors.yellow('Parameters:'))}`);
+        for (const [name, def] of Object.entries(schema.params)) {
+            if (def.hidden)
+                continue;
+            let syntax = `${name}=VAL`;
+            if (def.type !== 'string')
+                syntax = `${name}:=VAL`;
+            const typeLabel = def.type === 'string' ? '' : ` (${def.type})`;
+            const defaultLabel = def.default !== undefined ? ` (default: ${def.default})` : '';
+            const choicesLabel = def.choices ? ` [${def.choices.join('|')}]` : '';
+            const requiredLabel = def.required ? colors.red(' [required]') : '';
+            lines.push(`  ${colors.cyan(syntax.padEnd(25))} ${def.description}${typeLabel}${defaultLabel}${choicesLabel}${requiredLabel}`);
+        }
+        lines.push('');
+    }
+    if (schema.flags && Object.keys(schema.flags).length > 0) {
+        lines.push(`${colors.bold(colors.yellow('Options:'))}`);
+        for (const [name, def] of Object.entries(schema.flags)) {
+            const aliasPart = def.alias ? `-${def.alias}, ` : '    ';
+            const flagStr = `${aliasPart}--${name}`;
+            lines.push(`  ${colors.cyan(flagStr.padEnd(25))} ${def.description}`);
+        }
+        lines.push('');
+    }
+    if (schema.keywords && Object.keys(schema.keywords).length > 0) {
+        lines.push(`${colors.bold(colors.yellow('Keywords:'))}`);
+        for (const [name, def] of Object.entries(schema.keywords)) {
+            lines.push(`  ${colors.cyan(name.padEnd(25))} ${def.description}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}

package/dist/cli/parser/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './parser.js';
+export * from './help.js';

package/dist/cli/parser/index.js

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './parser.js';
+export * from './help.js';

package/dist/cli/parser/parser.d.ts

@@ -0,0 +1,4 @@
+import { CommandSchema, ParsedArgs } from './types.js';
+export declare class RekArgs {
+    static parse(rawArgs: string[], schema?: CommandSchema): ParsedArgs;
+}

package/dist/cli/parser/parser.js

@@ -0,0 +1,146 @@
+export class RekArgs {
+    static parse(rawArgs, schema) {
+        const result = {
+            args: [],
+            data: {},
+            headers: {},
+            options: {},
+            presets: [],
+            errors: []
+        };
+        if (schema) {
+            if (schema.params) {
+                for (const [key, def] of Object.entries(schema.params)) {
+                    if (def.default !== undefined) {
+                        result.data[key] = def.default;
+                    }
+                }
+            }
+            if (schema.flags) {
+                for (const [key, def] of Object.entries(schema.flags)) {
+                    if (def.default !== undefined) {
+                        result.options[key] = def.default;
+                    }
+                }
+            }
+        }
+        for (let i = 0; i < rawArgs.length; i++) {
+            const arg = rawArgs[i];
+            if (arg.startsWith('-')) {
+                const isLong = arg.startsWith('--');
+                const flagName = isLong ? arg.slice(2) : arg.slice(1);
+                let canonicalName = flagName;
+                if (schema?.flags) {
+                    if (!isLong) {
+                        const found = Object.entries(schema.flags).find(([k, v]) => v.alias === flagName);
+                        if (found)
+                            canonicalName = found[0];
+                    }
+                    if (schema.flags[canonicalName]) {
+                        result.options[canonicalName] = true;
+                        continue;
+                    }
+                }
+                result.options[canonicalName] = true;
+                continue;
+            }
+            if (arg.includes(':') && !arg.includes(':=') &&
+                !arg.match(/^(http|https|ws|wss|udp|ftp|sftp):\/\//)) {
+                const [key, ...rest] = arg.split(':');
+                const value = rest.join(':').trim();
+                result.headers[key.trim()] = value;
+                continue;
+            }
+            if (arg.includes(':=')) {
+                const [key, ...rest] = arg.split(':=');
+                const valStr = rest.join(':=');
+                const cleanKey = key.trim();
+                let value = valStr;
+                if (valStr === 'true')
+                    value = true;
+                else if (valStr === 'false')
+                    value = false;
+                else if (valStr === 'null')
+                    value = null;
+                else if (!isNaN(Number(valStr)) && valStr.trim() !== '')
+                    value = Number(valStr);
+                if (schema?.params && schema.params[cleanKey]) {
+                    const def = schema.params[cleanKey];
+                    if (def.choices && !def.choices.includes(String(value))) {
+                        result.errors.push(`Invalid value for '${cleanKey}': '${value}'. Allowed: ${def.choices.join(', ')}`);
+                    }
+                }
+                result.data[cleanKey] = value;
+                continue;
+            }
+            if (arg.includes('=')) {
+                const [key, ...rest] = arg.split('=');
+                const value = rest.join('=');
+                const cleanKey = key.trim();
+                let cleanValue = value;
+                if ((cleanValue.startsWith('"') && cleanValue.endsWith('"')) ||
+                    (cleanValue.startsWith("'") && cleanValue.endsWith("'"))) {
+                    cleanValue = cleanValue.slice(1, -1);
+                }
+                if (schema?.params && schema.params[cleanKey]) {
+                    const def = schema.params[cleanKey];
+                    if (def.type === 'number') {
+                        const num = Number(cleanValue);
+                        if (isNaN(num))
+                            result.errors.push(`Expected number for '${cleanKey}', got '${cleanValue}'`);
+                        else
+                            result.data[cleanKey] = num;
+                    }
+                    else if (def.type === 'boolean') {
+                        if (cleanValue === 'true')
+                            result.data[cleanKey] = true;
+                        else if (cleanValue === 'false')
+                            result.data[cleanKey] = false;
+                        else
+                            result.errors.push(`Expected boolean for '${cleanKey}', got '${cleanValue}'`);
+                    }
+                    else {
+                        if (def.choices && !def.choices.includes(cleanValue)) {
+                            result.errors.push(`Invalid value for '${cleanKey}': '${cleanValue}'. Allowed: ${def.choices.join(', ')}`);
+                        }
+                        else {
+                            result.data[cleanKey] = cleanValue;
+                        }
+                    }
+                }
+                else {
+                    result.data[cleanKey] = cleanValue;
+                }
+                continue;
+            }
+            if (arg.startsWith('+')) {
+                result.presets.push(arg.slice(1));
+                continue;
+            }
+            if (schema?.keywords && schema.keywords[arg]) {
+                const def = schema.keywords[arg];
+                const targetKey = def.mapTo || arg;
+                result.data[targetKey] = true;
+                continue;
+            }
+            result.args.push(arg);
+        }
+        if (schema) {
+            if (schema.positional) {
+                schema.positional.forEach((pos, index) => {
+                    if (pos.required && result.args[index] === undefined) {
+                        result.errors.push(`Missing required argument: <${pos.name}>`);
+                    }
+                });
+            }
+            if (schema.params) {
+                for (const [key, def] of Object.entries(schema.params)) {
+                    if (def.required && result.data[key] === undefined) {
+                        result.errors.push(`Missing required parameter: ${key}=value`);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}

package/dist/cli/parser/types.d.ts

@@ -0,0 +1,41 @@
+export type ParamType = 'string' | 'number' | 'boolean' | 'json';
+export interface ParamDef {
+    type: ParamType;
+    description: string;
+    default?: any;
+    required?: boolean;
+    choices?: string[];
+    hidden?: boolean;
+}
+export interface CommandSchema {
+    name: string;
+    description: string;
+    positional?: {
+        name: string;
+        description: string;
+        required?: boolean;
+        type?: ParamType;
+    }[];
+    params?: Record<string, ParamDef>;
+    flags?: Record<string, {
+        description: string;
+        alias?: string;
+        default?: boolean;
+    }>;
+    keywords?: Record<string, {
+        description: string;
+        mapTo?: string;
+    }>;
+    examples?: {
+        cmd: string;
+        desc: string;
+    }[];
+}
+export interface ParsedArgs {
+    args: (string | number | boolean)[];
+    data: Record<string, any>;
+    headers: Record<string, string>;
+    options: Record<string, boolean | string>;
+    presets: string[];
+    errors: string[];
+}

package/dist/cli/parser/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/presets.d.ts

@@ -2,4 +2,4 @@ export interface ResolvePresetOptions {
     throwOnError?: boolean;
     silent?: boolean;
 }
-export declare function resolvePreset(name: string, options?: ResolvePresetOptions): any;
+export declare function resolvePreset(name: string, options?: ResolvePresetOptions): Promise<any>;

package/dist/cli/presets.js

@@ -20,7 +20,7 @@ const ENV_MAPPING = {
     together: ['TOGETHER_API_KEY'],
     perplexity: ['PERPLEXITY_API_KEY'],
 };
-export function resolvePreset(name, options = {}) {
+export async function resolvePreset(name, options = {}) {
     const { throwOnError = false, silent = false } = options;
     const presetFn = presets[name];
     if (!presetFn) {

package/dist/cli/router.d.ts

@@ -0,0 +1,36 @@
+export declare function getGlobalPresets(): string[];
+export type ActionFn = (...args: any[]) => Promise<void> | void;
+export interface CommandOption {
+    flags: string;
+    description: string;
+    defaultValue?: any;
+}
+export declare class RekCommand {
+    name: string;
+    _description: string;
+    subcommands: RekCommand[];
+    options: CommandOption[];
+    _action?: ActionFn;
+    argsDefinition: string[];
+    parent?: RekCommand;
+    aliases: string[];
+    helpTextAfter: string;
+    currentArgs: string[];
+    constructor(name?: string);
+    command(nameAndArgs: string): RekCommand;
+    description(d: string): this;
+    alias(a: string): this;
+    aliasesList(): string[];
+    argument(name: string, desc?: string, defaultValue?: any): this;
+    option(flags: string, description: string, defaultValue?: any): this;
+    action(fn: ActionFn): this;
+    addHelpText(position: string, text: string | (() => string)): this;
+    showHelpAfterError(val: boolean): this;
+    allowUnknownOption(val?: boolean): this;
+    version(v: string): this;
+    parse(argv?: string[]): Promise<void>;
+    dispatch(args: string[]): Promise<void>;
+    opts(): Record<string, any>;
+    help(): void;
+    showHelp(): void;
+}

package/dist/cli/router.js

@@ -0,0 +1,195 @@
+import colors from '../utils/colors.js';
+let globalPresets = [];
+const KEYWORD_MAP = {
+    verbose: '--verbose',
+    quiet: '--quiet',
+    json: '--json',
+    help: '--help',
+    version: '--version',
+    secure: '--secure',
+    implicit: '--implicit',
+    live: '--live'
+};
+export function getGlobalPresets() {
+    return globalPresets;
+}
+export class RekCommand {
+    name;
+    _description = '';
+    subcommands = [];
+    options = [];
+    _action;
+    argsDefinition = [];
+    parent;
+    aliases = [];
+    helpTextAfter = '';
+    currentArgs = [];
+    constructor(name = 'rek') {
+        this.name = name;
+    }
+    command(nameAndArgs) {
+        const parts = nameAndArgs.split(/ +/);
+        const name = parts[0];
+        const args = parts.slice(1);
+        const cmd = new RekCommand(name);
+        cmd.argsDefinition = args;
+        cmd.parent = this;
+        this.subcommands.push(cmd);
+        return cmd;
+    }
+    description(d) {
+        this._description = d;
+        return this;
+    }
+    alias(a) {
+        this.aliases.push(a);
+        return this;
+    }
+    aliasesList() {
+        return this.aliases;
+    }
+    argument(name, desc, defaultValue) {
+        this.argsDefinition.push(name);
+        return this;
+    }
+    option(flags, description, defaultValue) {
+        this.options.push({ flags, description, defaultValue });
+        return this;
+    }
+    action(fn) {
+        this._action = fn;
+        return this;
+    }
+    addHelpText(position, text) {
+        this.helpTextAfter = typeof text === 'function' ? text() : text;
+        return this;
+    }
+    showHelpAfterError(val) { return this; }
+    allowUnknownOption(val) { return this; }
+    version(v) { return this; }
+    async parse(argv = process.argv) {
+        const cleanedArgv = [];
+        const presets = [];
+        const [nodeBin, scriptPath, ...userArgs] = argv;
+        cleanedArgv.push(nodeBin, scriptPath);
+        for (const arg of userArgs) {
+            if (arg.startsWith('+')) {
+                presets.push(arg.slice(1));
+                continue;
+            }
+            if (KEYWORD_MAP[arg]) {
+                cleanedArgv.push(KEYWORD_MAP[arg]);
+                continue;
+            }
+            cleanedArgv.push(arg);
+        }
+        globalPresets = presets;
+        const args = cleanedArgv.slice(2).filter(a => a !== '--');
+        try {
+            await this.dispatch(args);
+        }
+        catch (err) {
+            console.error(colors.red(`\nError: ${err.message}\n`));
+            process.exit(1);
+        }
+    }
+    async dispatch(args) {
+        this.currentArgs = args;
+        if (args.includes('--help') || args.includes('-h')) {
+            this.showHelp();
+            return;
+        }
+        const firstArg = args[0];
+        const sub = this.subcommands.find(c => c.name === firstArg || c.aliases.includes(firstArg));
+        if (sub) {
+            await sub.dispatch(args.slice(1));
+            return;
+        }
+        if (this._action) {
+            const positionalArgs = args.filter(a => !a.startsWith('-') && a !== '--');
+            if (this.name === 'rek') {
+                await this._action(args, this.opts());
+            }
+            else {
+                const params = [];
+                let hasVariadic = false;
+                let reqArgsCount = 0;
+                for (const def of this.argsDefinition) {
+                    if (def.startsWith('[') && def.includes('...'))
+                        hasVariadic = true;
+                    else if (def.startsWith('<'))
+                        reqArgsCount++;
+                }
+                for (let i = 0; i < reqArgsCount; i++) {
+                    params.push(positionalArgs[i]);
+                }
+                params.push(args);
+                params.push(this);
+                await this._action(...params);
+            }
+            return;
+        }
+        if (args.length > 0) {
+            console.error(colors.red(`Unknown command: '${args[0]}'`));
+            console.log(colors.gray(`Run 'rek --help' for available commands.`));
+            process.exit(1);
+        }
+        this.showHelp();
+    }
+    opts() {
+        const opts = {};
+        for (const arg of this.currentArgs) {
+            if (arg.startsWith('--')) {
+                const parts = arg.slice(2).split('=');
+                const key = parts[0];
+                const val = parts.length > 1 ? parts.slice(1).join('=') : true;
+                if (key.startsWith('no-')) {
+                    opts[key.slice(3)] = false;
+                }
+                else {
+                    opts[key] = val;
+                }
+            }
+            else if (arg.startsWith('-')) {
+                const flag = arg.slice(1);
+                const optionDef = this.options.find(o => o.flags.includes(`-${flag},`));
+                if (optionDef) {
+                    const longName = optionDef.flags.split(',')[1].trim().replace('--', '');
+                    opts[longName] = true;
+                }
+                else {
+                    opts[flag] = true;
+                }
+            }
+        }
+        return opts;
+    }
+    help() {
+        this.showHelp();
+    }
+    showHelp() {
+        console.log(`
+${colors.bold(this.name)} - ${this._description}`);
+        console.log(`
+${colors.yellow('Usage:')} 
+  ${this.name} ${this.argsDefinition.join(' ')} [options] [command]`);
+        if (this.subcommands.length > 0) {
+            console.log(`
+${colors.yellow('Commands:')}`);
+            for (const c of this.subcommands) {
+                console.log(`  ${colors.cyan(c.name.padEnd(12))} ${c._description}`);
+            }
+        }
+        if (this.options.length > 0) {
+            console.log(`
+${colors.yellow('Options:')}`);
+            for (const o of this.options) {
+                console.log(`  ${colors.green(o.flags.padEnd(20))} ${o.description}`);
+            }
+        }
+        if (this.helpTextAfter) {
+            console.log(this.helpTextAfter);
+        }
+        process.exit(0);
+    }
+}

package/dist/cli/tui/ai-chat.js

@@ -152,7 +152,7 @@ async function getOrCreateClient(provider, context) {
         return client;
     }
     try {
-        const presetConfig = resolvePreset(provider);
+        const presetConfig = await resolvePreset(provider, { throwOnError: true });
         if (!presetConfig) {
             console.log(colors.red(`Unknown preset: ${provider}`));
             return null;

package/dist/cli/tui/commands/context.d.ts

@@ -0,0 +1,9 @@
+import { Client } from '../../../core/client.js';
+export interface ShellContext {
+    client: Client;
+    baseUrl?: string;
+    currentDocUrl?: string;
+    lastResponse?: any;
+    getBaseDomain(): string | undefined | null;
+    getRootDomain(): string | undefined | null;
+}

package/dist/cli/tui/commands/context.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/tui/commands/dns.d.ts

@@ -0,0 +1,10 @@
+import { ShellContext } from './context.js';
+export declare function runDns(ctx: ShellContext, domain?: string): Promise<void>;
+export declare function runDnsPropagation(ctx: ShellContext, domain: string, type?: string): Promise<void>;
+export declare function runDnsEmailCheck(ctx: ShellContext, domain?: string, selector?: string): Promise<void>;
+export declare function runDnsHealth(ctx: ShellContext, domain?: string): Promise<void>;
+export declare function runDnsSpf(ctx: ShellContext, domain?: string): Promise<void>;
+export declare function runDnsDmarc(ctx: ShellContext, domain?: string): Promise<void>;
+export declare function runDnsDkim(ctx: ShellContext, domain?: string, selector?: string): Promise<void>;
+export declare function runDnsDig(ctx: ShellContext, args: string[]): Promise<void>;
+export declare function runDnsGenerate(ctx: ShellContext, args: string[]): Promise<void>;