@robinpath/cli 1.73.0

package/modules/child.js

@@ -0,0 +1,176 @@
+/**
+ * Native child process module for RobinPath.
+ * Execute system commands and spawn processes.
+ */
+import { exec as _exec, execSync as _execSync, spawn as _spawn } from 'node:child_process';
+import { toStr, toNum, requireArgs } from './_helpers.js';
+
+const _processes = new Map();
+let _nextId = 1;
+
+export const ChildFunctions = {
+
+    exec: (args) => {
+        requireArgs('child.exec', args, 1);
+        const command = toStr(args[0]);
+        const opts = {};
+        if (args[1] && typeof args[1] === 'object') {
+            if (args[1].cwd) opts.cwd = toStr(args[1].cwd);
+            if (args[1].timeout) opts.timeout = toNum(args[1].timeout);
+            if (args[1].encoding) opts.encoding = toStr(args[1].encoding);
+            if (args[1].env) opts.env = { ...process.env, ...args[1].env };
+            if (args[1].maxBuffer) opts.maxBuffer = toNum(args[1].maxBuffer);
+            if (args[1].shell) opts.shell = toStr(args[1].shell);
+        }
+        opts.encoding = opts.encoding || 'utf-8';
+
+        return new Promise((resolve, reject) => {
+            _exec(command, opts, (error, stdout, stderr) => {
+                resolve({
+                    stdout: stdout || '',
+                    stderr: stderr || '',
+                    code: error ? error.code ?? 1 : 0,
+                    error: error ? error.message : null
+                });
+            });
+        });
+    },
+
+    execSync: (args) => {
+        requireArgs('child.execSync', args, 1);
+        const command = toStr(args[0]);
+        const opts = { encoding: 'utf-8' };
+        if (args[1] && typeof args[1] === 'object') {
+            if (args[1].cwd) opts.cwd = toStr(args[1].cwd);
+            if (args[1].timeout) opts.timeout = toNum(args[1].timeout);
+            if (args[1].shell) opts.shell = toStr(args[1].shell);
+        }
+        try {
+            return _execSync(command, opts);
+        } catch (err) {
+            return {
+                stdout: err.stdout || '',
+                stderr: err.stderr || '',
+                code: err.status ?? 1,
+                error: err.message
+            };
+        }
+    },
+
+    spawn: (args) => {
+        requireArgs('child.spawn', args, 1);
+        const command = toStr(args[0]);
+        const spawnArgs = Array.isArray(args[1]) ? args[1].map(a => toStr(a)) : [];
+        const opts = { shell: true };
+        if (args[2] && typeof args[2] === 'object') {
+            if (args[2].cwd) opts.cwd = toStr(args[2].cwd);
+            if (args[2].env) opts.env = { ...process.env, ...args[2].env };
+            if (args[2].shell !== undefined) opts.shell = args[2].shell;
+            if (args[2].detached) opts.detached = true;
+        }
+
+        const child = _spawn(command, spawnArgs, opts);
+        const id = `proc_${_nextId++}`;
+        let stdout = '';
+        let stderr = '';
+
+        if (child.stdout) child.stdout.on('data', (d) => { stdout += d; });
+        if (child.stderr) child.stderr.on('data', (d) => { stderr += d; });
+
+        const resultPromise = new Promise((resolve) => {
+            child.on('close', (code) => {
+                _processes.delete(id);
+                resolve({ id, stdout, stderr, code: code ?? 0 });
+            });
+            child.on('error', (err) => {
+                _processes.delete(id);
+                resolve({ id, stdout, stderr, code: 1, error: err.message });
+            });
+        });
+
+        _processes.set(id, { child, resultPromise });
+        return id;
+    },
+
+    wait: async (args) => {
+        requireArgs('child.wait', args, 1);
+        const id = toStr(args[0]);
+        const proc = _processes.get(id);
+        if (!proc) return { error: `Process ${id} not found` };
+        return await proc.resultPromise;
+    },
+
+    kill: (args) => {
+        requireArgs('child.kill', args, 1);
+        const id = toStr(args[0]);
+        const signal = toStr(args[1], 'SIGTERM');
+        const proc = _processes.get(id);
+        if (!proc) return false;
+        proc.child.kill(signal);
+        _processes.delete(id);
+        return true;
+    },
+
+    running: () => {
+        return Array.from(_processes.keys());
+    }
+};
+
+export const ChildFunctionMetadata = {
+    exec: {
+        description: 'Execute a shell command and return output',
+        parameters: [
+            { name: 'command', dataType: 'string', description: 'Shell command to execute', formInputType: 'text', required: true },
+            { name: 'options', dataType: 'object', description: 'Options: cwd, timeout, encoding, env, maxBuffer, shell', formInputType: 'json', required: false }
+        ],
+        returnType: 'object', returnDescription: 'Object with stdout, stderr, code, error', example: 'child.exec "ls -la"'
+    },
+    execSync: {
+        description: 'Execute a shell command synchronously',
+        parameters: [
+            { name: 'command', dataType: 'string', description: 'Shell command', formInputType: 'text', required: true },
+            { name: 'options', dataType: 'object', description: 'Options: cwd, timeout, shell', formInputType: 'json', required: false }
+        ],
+        returnType: 'string', returnDescription: 'Command output string', example: 'child.execSync "echo hello"'
+    },
+    spawn: {
+        description: 'Spawn a child process (non-blocking)',
+        parameters: [
+            { name: 'command', dataType: 'string', description: 'Command to run', formInputType: 'text', required: true },
+            { name: 'args', dataType: 'array', description: 'Command arguments', formInputType: 'json', required: false },
+            { name: 'options', dataType: 'object', description: 'Options: cwd, env, shell, detached', formInputType: 'json', required: false }
+        ],
+        returnType: 'string', returnDescription: 'Process handle ID', example: 'child.spawn "node" ["server.js"]'
+    },
+    wait: {
+        description: 'Wait for a spawned process to finish',
+        parameters: [{ name: 'processId', dataType: 'string', description: 'Process handle ID from spawn', formInputType: 'text', required: true }],
+        returnType: 'object', returnDescription: 'Object with stdout, stderr, code', example: 'child.wait $pid'
+    },
+    kill: {
+        description: 'Kill a spawned process',
+        parameters: [
+            { name: 'processId', dataType: 'string', description: 'Process handle ID', formInputType: 'text', required: true },
+            { name: 'signal', dataType: 'string', description: 'Signal (default: SIGTERM)', formInputType: 'text', required: false, defaultValue: 'SIGTERM' }
+        ],
+        returnType: 'boolean', returnDescription: 'true if killed', example: 'child.kill $pid'
+    },
+    running: {
+        description: 'List all running spawned processes',
+        parameters: [],
+        returnType: 'array', returnDescription: 'Array of process handle IDs', example: 'child.running'
+    }
+};
+
+export const ChildModuleMetadata = {
+    description: 'Child process execution: exec, execSync, spawn, kill, and process management',
+    methods: Object.keys(ChildFunctions)
+};
+
+export default {
+    name: 'child',
+    functions: ChildFunctions,
+    functionMetadata: ChildFunctionMetadata,
+    moduleMetadata: ChildModuleMetadata,
+    global: false
+};

package/modules/crypto.js

@@ -0,0 +1,352 @@
+/**
+ * Native crypto module for RobinPath.
+ * Full cryptographic operations powered by Node.js crypto.
+ */
+import {
+    createHash, createHmac, createCipheriv, createDecipheriv,
+    randomBytes, randomUUID, randomInt, pbkdf2 as _pbkdf2, scrypt as _scrypt,
+    getCiphers, getHashes
+} from 'node:crypto';
+import { toStr, toNum, requireArgs } from './_helpers.js';
+
+export const CryptoNativeFunctions = {
+
+    // --- Hashing ---
+
+    hash: async (args) => {
+        requireArgs('crypto.hash', args, 2);
+        const algo = toStr(args[0]);
+        const data = toStr(args[1]);
+        const encoding = toStr(args[2], 'hex');
+        return createHash(algo).update(data).digest(encoding);
+    },
+
+    md5: async (args) => {
+        requireArgs('crypto.md5', args, 1);
+        return createHash('md5').update(toStr(args[0])).digest('hex');
+    },
+
+    sha1: async (args) => {
+        requireArgs('crypto.sha1', args, 1);
+        return createHash('sha1').update(toStr(args[0])).digest('hex');
+    },
+
+    sha256: async (args) => {
+        requireArgs('crypto.sha256', args, 1);
+        return createHash('sha256').update(toStr(args[0])).digest('hex');
+    },
+
+    sha512: async (args) => {
+        requireArgs('crypto.sha512', args, 1);
+        return createHash('sha512').update(toStr(args[0])).digest('hex');
+    },
+
+    // --- HMAC ---
+
+    hmac: async (args) => {
+        requireArgs('crypto.hmac', args, 3);
+        const algo = toStr(args[0]);
+        const key = toStr(args[1]);
+        const data = toStr(args[2]);
+        const encoding = toStr(args[3], 'hex');
+        return createHmac(algo, key).update(data).digest(encoding);
+    },
+
+    hmacSha256: async (args) => {
+        requireArgs('crypto.hmacSha256', args, 2);
+        return createHmac('sha256', toStr(args[0])).update(toStr(args[1])).digest('hex');
+    },
+
+    hmacSha512: async (args) => {
+        requireArgs('crypto.hmacSha512', args, 2);
+        return createHmac('sha512', toStr(args[0])).update(toStr(args[1])).digest('hex');
+    },
+
+    // --- Encryption ---
+
+    encrypt: async (args) => {
+        requireArgs('crypto.encrypt', args, 3);
+        const algo = toStr(args[0], 'aes-256-cbc');
+        const key = toStr(args[1]);
+        const data = toStr(args[2]);
+        // Derive a 32-byte key from the input key
+        const keyBuf = createHash('sha256').update(key).digest();
+        // Generate random IV
+        const iv = randomBytes(16);
+        const cipher = createCipheriv(algo, keyBuf, iv);
+        let encrypted = cipher.update(data, 'utf-8', 'hex');
+        encrypted += cipher.final('hex');
+        // Return IV + encrypted data separated by ':'
+        return iv.toString('hex') + ':' + encrypted;
+    },
+
+    decrypt: async (args) => {
+        requireArgs('crypto.decrypt', args, 3);
+        const algo = toStr(args[0], 'aes-256-cbc');
+        const key = toStr(args[1]);
+        const encryptedStr = toStr(args[2]);
+        const keyBuf = createHash('sha256').update(key).digest();
+        const parts = encryptedStr.split(':');
+        if (parts.length !== 2) throw new Error('crypto.decrypt: invalid encrypted data format (expected iv:data)');
+        const iv = Buffer.from(parts[0], 'hex');
+        const encrypted = parts[1];
+        const decipher = createDecipheriv(algo, keyBuf, iv);
+        let decrypted = decipher.update(encrypted, 'hex', 'utf-8');
+        decrypted += decipher.final('utf-8');
+        return decrypted;
+    },
+
+    // --- Random ---
+
+    randomBytes: async (args) => {
+        const size = toNum(args[0], 32);
+        const encoding = toStr(args[1], 'hex');
+        return randomBytes(size).toString(encoding);
+    },
+
+    randomUUID: () => randomUUID(),
+
+    randomInt: (args) => {
+        const min = args.length >= 2 ? toNum(args[0], 0) : 0;
+        const max = args.length >= 2 ? toNum(args[1], 100) : toNum(args[0], 100);
+        return randomInt(min, max);
+    },
+
+    // --- Key Derivation ---
+
+    pbkdf2: (args) => {
+        requireArgs('crypto.pbkdf2', args, 2);
+        const password = toStr(args[0]);
+        const salt = toStr(args[1], 'salt');
+        const iterations = toNum(args[2], 100000);
+        const keylen = toNum(args[3], 64);
+        const digest = toStr(args[4], 'sha512');
+        return new Promise((resolve, reject) => {
+            _pbkdf2(password, salt, iterations, keylen, digest, (err, key) => {
+                if (err) reject(err);
+                else resolve(key.toString('hex'));
+            });
+        });
+    },
+
+    scrypt: (args) => {
+        requireArgs('crypto.scrypt', args, 2);
+        const password = toStr(args[0]);
+        const salt = toStr(args[1]);
+        const keylen = toNum(args[2], 64);
+        return new Promise((resolve, reject) => {
+            _scrypt(password, salt, keylen, (err, key) => {
+                if (err) reject(err);
+                else resolve(key.toString('hex'));
+            });
+        });
+    },
+
+    // --- Encoding ---
+
+    base64Encode: (args) => {
+        requireArgs('crypto.base64Encode', args, 1);
+        return Buffer.from(toStr(args[0])).toString('base64');
+    },
+
+    base64Decode: (args) => {
+        requireArgs('crypto.base64Decode', args, 1);
+        return Buffer.from(toStr(args[0]), 'base64').toString('utf-8');
+    },
+
+    base64UrlEncode: (args) => {
+        requireArgs('crypto.base64UrlEncode', args, 1);
+        return Buffer.from(toStr(args[0])).toString('base64url');
+    },
+
+    base64UrlDecode: (args) => {
+        requireArgs('crypto.base64UrlDecode', args, 1);
+        return Buffer.from(toStr(args[0]), 'base64url').toString('utf-8');
+    },
+
+    hexEncode: (args) => {
+        requireArgs('crypto.hexEncode', args, 1);
+        return Buffer.from(toStr(args[0])).toString('hex');
+    },
+
+    hexDecode: (args) => {
+        requireArgs('crypto.hexDecode', args, 1);
+        return Buffer.from(toStr(args[0]), 'hex').toString('utf-8');
+    },
+
+    // --- Info ---
+
+    ciphers: () => getCiphers(),
+
+    hashes: () => getHashes()
+};
+
+export const CryptoNativeFunctionMetadata = {
+    hash: {
+        description: 'Hash data with any supported algorithm',
+        parameters: [
+            { name: 'algorithm', dataType: 'string', description: 'Hash algorithm (md5, sha256, sha512, etc.)', formInputType: 'text', required: true },
+            { name: 'data', dataType: 'string', description: 'Data to hash', formInputType: 'text', required: true },
+            { name: 'encoding', dataType: 'string', description: 'Output encoding (hex, base64)', formInputType: 'text', required: false, defaultValue: 'hex' }
+        ],
+        returnType: 'string', returnDescription: 'Hash digest', example: 'crypto.hash "sha256" "hello"'
+    },
+    md5: {
+        description: 'MD5 hash',
+        parameters: [{ name: 'data', dataType: 'string', description: 'Data to hash', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'MD5 hex digest', example: 'crypto.md5 "hello"'
+    },
+    sha1: {
+        description: 'SHA-1 hash',
+        parameters: [{ name: 'data', dataType: 'string', description: 'Data to hash', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'SHA-1 hex digest', example: 'crypto.sha1 "hello"'
+    },
+    sha256: {
+        description: 'SHA-256 hash',
+        parameters: [{ name: 'data', dataType: 'string', description: 'Data to hash', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'SHA-256 hex digest', example: 'crypto.sha256 "hello"'
+    },
+    sha512: {
+        description: 'SHA-512 hash',
+        parameters: [{ name: 'data', dataType: 'string', description: 'Data to hash', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'SHA-512 hex digest', example: 'crypto.sha512 "hello"'
+    },
+    hmac: {
+        description: 'HMAC with any algorithm',
+        parameters: [
+            { name: 'algorithm', dataType: 'string', description: 'Hash algorithm', formInputType: 'text', required: true },
+            { name: 'key', dataType: 'string', description: 'Secret key', formInputType: 'text', required: true },
+            { name: 'data', dataType: 'string', description: 'Data to sign', formInputType: 'text', required: true },
+            { name: 'encoding', dataType: 'string', description: 'Output encoding', formInputType: 'text', required: false, defaultValue: 'hex' }
+        ],
+        returnType: 'string', returnDescription: 'HMAC digest', example: 'crypto.hmac "sha256" "secret" "data"'
+    },
+    hmacSha256: {
+        description: 'HMAC-SHA256',
+        parameters: [
+            { name: 'key', dataType: 'string', description: 'Secret key', formInputType: 'text', required: true },
+            { name: 'data', dataType: 'string', description: 'Data to sign', formInputType: 'text', required: true }
+        ],
+        returnType: 'string', returnDescription: 'HMAC-SHA256 hex digest', example: 'crypto.hmacSha256 "secret" "data"'
+    },
+    hmacSha512: {
+        description: 'HMAC-SHA512',
+        parameters: [
+            { name: 'key', dataType: 'string', description: 'Secret key', formInputType: 'text', required: true },
+            { name: 'data', dataType: 'string', description: 'Data to sign', formInputType: 'text', required: true }
+        ],
+        returnType: 'string', returnDescription: 'HMAC-SHA512 hex digest', example: 'crypto.hmacSha512 "secret" "data"'
+    },
+    encrypt: {
+        description: 'Encrypt data with AES (returns iv:ciphertext)',
+        parameters: [
+            { name: 'algorithm', dataType: 'string', description: 'Cipher algorithm (default: aes-256-cbc)', formInputType: 'text', required: false, defaultValue: 'aes-256-cbc' },
+            { name: 'key', dataType: 'string', description: 'Encryption key (hashed to 32 bytes)', formInputType: 'text', required: true },
+            { name: 'data', dataType: 'string', description: 'Data to encrypt', formInputType: 'text', required: true }
+        ],
+        returnType: 'string', returnDescription: 'iv:encryptedHex string', example: 'crypto.encrypt "aes-256-cbc" "mykey" "secret data"'
+    },
+    decrypt: {
+        description: 'Decrypt data from encrypt() output',
+        parameters: [
+            { name: 'algorithm', dataType: 'string', description: 'Cipher algorithm', formInputType: 'text', required: false, defaultValue: 'aes-256-cbc' },
+            { name: 'key', dataType: 'string', description: 'Encryption key', formInputType: 'text', required: true },
+            { name: 'encryptedData', dataType: 'string', description: 'iv:ciphertext from encrypt()', formInputType: 'text', required: true }
+        ],
+        returnType: 'string', returnDescription: 'Decrypted string', example: 'crypto.decrypt "aes-256-cbc" "mykey" $encrypted'
+    },
+    randomBytes: {
+        description: 'Generate random bytes',
+        parameters: [
+            { name: 'size', dataType: 'number', description: 'Number of bytes (default: 32)', formInputType: 'number', required: false, defaultValue: 32 },
+            { name: 'encoding', dataType: 'string', description: 'Output encoding (hex, base64)', formInputType: 'text', required: false, defaultValue: 'hex' }
+        ],
+        returnType: 'string', returnDescription: 'Random bytes as encoded string', example: 'crypto.randomBytes 16'
+    },
+    randomUUID: {
+        description: 'Generate a random UUID v4',
+        parameters: [],
+        returnType: 'string', returnDescription: 'UUID v4 string', example: 'crypto.randomUUID'
+    },
+    randomInt: {
+        description: 'Generate a random integer',
+        parameters: [
+            { name: 'min', dataType: 'number', description: 'Minimum (or max if single arg)', formInputType: 'number', required: false, defaultValue: 0 },
+            { name: 'max', dataType: 'number', description: 'Maximum (exclusive)', formInputType: 'number', required: false, defaultValue: 100 }
+        ],
+        returnType: 'number', returnDescription: 'Random integer', example: 'crypto.randomInt 1 100'
+    },
+    pbkdf2: {
+        description: 'Derive key using PBKDF2',
+        parameters: [
+            { name: 'password', dataType: 'string', description: 'Password', formInputType: 'text', required: true },
+            { name: 'salt', dataType: 'string', description: 'Salt', formInputType: 'text', required: true },
+            { name: 'iterations', dataType: 'number', description: 'Iterations (default: 100000)', formInputType: 'number', required: false, defaultValue: 100000 },
+            { name: 'keylen', dataType: 'number', description: 'Key length (default: 64)', formInputType: 'number', required: false, defaultValue: 64 },
+            { name: 'digest', dataType: 'string', description: 'Digest algorithm (default: sha512)', formInputType: 'text', required: false, defaultValue: 'sha512' }
+        ],
+        returnType: 'string', returnDescription: 'Derived key as hex', example: 'crypto.pbkdf2 "password" "salt"'
+    },
+    scrypt: {
+        description: 'Derive key using scrypt',
+        parameters: [
+            { name: 'password', dataType: 'string', description: 'Password', formInputType: 'text', required: true },
+            { name: 'salt', dataType: 'string', description: 'Salt', formInputType: 'text', required: true },
+            { name: 'keylen', dataType: 'number', description: 'Key length (default: 64)', formInputType: 'number', required: false, defaultValue: 64 }
+        ],
+        returnType: 'string', returnDescription: 'Derived key as hex', example: 'crypto.scrypt "password" "salt"'
+    },
+    base64Encode: {
+        description: 'Encode string to Base64',
+        parameters: [{ name: 'data', dataType: 'string', description: 'Data to encode', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'Base64 encoded string', example: 'crypto.base64Encode "hello"'
+    },
+    base64Decode: {
+        description: 'Decode Base64 to string',
+        parameters: [{ name: 'data', dataType: 'string', description: 'Base64 data', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'Decoded string', example: 'crypto.base64Decode "aGVsbG8="'
+    },
+    base64UrlEncode: {
+        description: 'Encode string to URL-safe Base64',
+        parameters: [{ name: 'data', dataType: 'string', description: 'Data to encode', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'Base64url encoded string', example: 'crypto.base64UrlEncode "hello"'
+    },
+    base64UrlDecode: {
+        description: 'Decode URL-safe Base64 to string',
+        parameters: [{ name: 'data', dataType: 'string', description: 'Base64url data', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'Decoded string', example: 'crypto.base64UrlDecode "aGVsbG8"'
+    },
+    hexEncode: {
+        description: 'Encode string to hex',
+        parameters: [{ name: 'data', dataType: 'string', description: 'Data to encode', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'Hex encoded string', example: 'crypto.hexEncode "hello"'
+    },
+    hexDecode: {
+        description: 'Decode hex to string',
+        parameters: [{ name: 'data', dataType: 'string', description: 'Hex data', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'Decoded string', example: 'crypto.hexDecode "68656c6c6f"'
+    },
+    ciphers: {
+        description: 'List all supported cipher algorithms',
+        parameters: [],
+        returnType: 'array', returnDescription: 'Array of cipher names', example: 'crypto.ciphers'
+    },
+    hashes: {
+        description: 'List all supported hash algorithms',
+        parameters: [],
+        returnType: 'array', returnDescription: 'Array of hash names', example: 'crypto.hashes'
+    }
+};
+
+export const CryptoNativeModuleMetadata = {
+    description: 'Cryptographic operations: hashing, HMAC, encryption, key derivation, random generation, and encoding',
+    methods: Object.keys(CryptoNativeFunctions)
+};
+
+export default {
+    name: 'crypto',
+    functions: CryptoNativeFunctions,
+    functionMetadata: CryptoNativeFunctionMetadata,
+    moduleMetadata: CryptoNativeModuleMetadata,
+    global: false
+};

package/modules/dns.js

@@ -0,0 +1,146 @@
+/**
+ * Native DNS module for RobinPath.
+ * DNS resolution and lookup.
+ */
+import { promises as dns } from 'node:dns';
+import { toStr, requireArgs } from './_helpers.js';
+
+export const DnsFunctions = {
+
+    lookup: async (args) => {
+        requireArgs('dns.lookup', args, 1);
+        const hostname = toStr(args[0]);
+        const result = await dns.lookup(hostname, { all: true });
+        if (Array.isArray(result)) {
+            return result.map(r => ({ address: r.address, family: r.family }));
+        }
+        return { address: result.address, family: result.family };
+    },
+
+    resolve: async (args) => {
+        requireArgs('dns.resolve', args, 1);
+        const hostname = toStr(args[0]);
+        const rrtype = toStr(args[1], 'A');
+        return await dns.resolve(hostname, rrtype);
+    },
+
+    resolve4: async (args) => {
+        requireArgs('dns.resolve4', args, 1);
+        return await dns.resolve4(toStr(args[0]));
+    },
+
+    resolve6: async (args) => {
+        requireArgs('dns.resolve6', args, 1);
+        return await dns.resolve6(toStr(args[0]));
+    },
+
+    resolveMx: async (args) => {
+        requireArgs('dns.resolveMx', args, 1);
+        return await dns.resolveMx(toStr(args[0]));
+    },
+
+    resolveTxt: async (args) => {
+        requireArgs('dns.resolveTxt', args, 1);
+        const records = await dns.resolveTxt(toStr(args[0]));
+        return records.map(r => r.join(''));
+    },
+
+    resolveNs: async (args) => {
+        requireArgs('dns.resolveNs', args, 1);
+        return await dns.resolveNs(toStr(args[0]));
+    },
+
+    resolveCname: async (args) => {
+        requireArgs('dns.resolveCname', args, 1);
+        return await dns.resolveCname(toStr(args[0]));
+    },
+
+    resolveSrv: async (args) => {
+        requireArgs('dns.resolveSrv', args, 1);
+        return await dns.resolveSrv(toStr(args[0]));
+    },
+
+    resolveSoa: async (args) => {
+        requireArgs('dns.resolveSoa', args, 1);
+        return await dns.resolveSoa(toStr(args[0]));
+    },
+
+    reverse: async (args) => {
+        requireArgs('dns.reverse', args, 1);
+        return await dns.reverse(toStr(args[0]));
+    }
+};
+
+export const DnsFunctionMetadata = {
+    lookup: {
+        description: 'Resolve hostname to IP address(es)',
+        parameters: [{ name: 'hostname', dataType: 'string', description: 'Hostname to resolve', formInputType: 'text', required: true }],
+        returnType: 'array', returnDescription: 'Array of {address, family}', example: 'dns.lookup "google.com"'
+    },
+    resolve: {
+        description: 'Resolve DNS records by type',
+        parameters: [
+            { name: 'hostname', dataType: 'string', description: 'Hostname', formInputType: 'text', required: true },
+            { name: 'rrtype', dataType: 'string', description: 'Record type (A, AAAA, MX, TXT, etc.)', formInputType: 'text', required: false, defaultValue: 'A' }
+        ],
+        returnType: 'array', returnDescription: 'Array of DNS records', example: 'dns.resolve "example.com" "MX"'
+    },
+    resolve4: {
+        description: 'Resolve IPv4 addresses',
+        parameters: [{ name: 'hostname', dataType: 'string', description: 'Hostname', formInputType: 'text', required: true }],
+        returnType: 'array', returnDescription: 'Array of IPv4 addresses', example: 'dns.resolve4 "google.com"'
+    },
+    resolve6: {
+        description: 'Resolve IPv6 addresses',
+        parameters: [{ name: 'hostname', dataType: 'string', description: 'Hostname', formInputType: 'text', required: true }],
+        returnType: 'array', returnDescription: 'Array of IPv6 addresses', example: 'dns.resolve6 "google.com"'
+    },
+    resolveMx: {
+        description: 'Resolve MX (mail) records',
+        parameters: [{ name: 'hostname', dataType: 'string', description: 'Domain', formInputType: 'text', required: true }],
+        returnType: 'array', returnDescription: 'Array of {exchange, priority}', example: 'dns.resolveMx "gmail.com"'
+    },
+    resolveTxt: {
+        description: 'Resolve TXT records',
+        parameters: [{ name: 'hostname', dataType: 'string', description: 'Domain', formInputType: 'text', required: true }],
+        returnType: 'array', returnDescription: 'Array of TXT record strings', example: 'dns.resolveTxt "example.com"'
+    },
+    resolveNs: {
+        description: 'Resolve NS (nameserver) records',
+        parameters: [{ name: 'hostname', dataType: 'string', description: 'Domain', formInputType: 'text', required: true }],
+        returnType: 'array', returnDescription: 'Array of nameserver hostnames', example: 'dns.resolveNs "example.com"'
+    },
+    resolveCname: {
+        description: 'Resolve CNAME records',
+        parameters: [{ name: 'hostname', dataType: 'string', description: 'Hostname', formInputType: 'text', required: true }],
+        returnType: 'array', returnDescription: 'Array of CNAME records', example: 'dns.resolveCname "www.example.com"'
+    },
+    resolveSrv: {
+        description: 'Resolve SRV records',
+        parameters: [{ name: 'hostname', dataType: 'string', description: 'Hostname', formInputType: 'text', required: true }],
+        returnType: 'array', returnDescription: 'Array of SRV records', example: 'dns.resolveSrv "_http._tcp.example.com"'
+    },
+    resolveSoa: {
+        description: 'Resolve SOA (Start of Authority) record',
+        parameters: [{ name: 'hostname', dataType: 'string', description: 'Domain', formInputType: 'text', required: true }],
+        returnType: 'object', returnDescription: 'SOA record object', example: 'dns.resolveSoa "example.com"'
+    },
+    reverse: {
+        description: 'Reverse DNS lookup (IP to hostname)',
+        parameters: [{ name: 'ip', dataType: 'string', description: 'IP address', formInputType: 'text', required: true }],
+        returnType: 'array', returnDescription: 'Array of hostnames', example: 'dns.reverse "8.8.8.8"'
+    }
+};
+
+export const DnsModuleMetadata = {
+    description: 'DNS resolution: lookup, resolve A/AAAA/MX/TXT/NS/SRV/SOA records, reverse lookup',
+    methods: Object.keys(DnsFunctions)
+};
+
+export default {
+    name: 'dns',
+    functions: DnsFunctions,
+    functionMetadata: DnsFunctionMetadata,
+    moduleMetadata: DnsModuleMetadata,
+    global: false
+};