@robinpath/cli 1.73.0

package/modules/tls.js

@@ -0,0 +1,264 @@
+/**
+ * Native TLS module for RobinPath.
+ * TLS/SSL secure connections — required by databases, email, websockets.
+ */
+import { connect as _tlsConnect, createServer as _tlsCreateServer, TLSSocket } from 'node:tls';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { toStr, toNum, requireArgs } from './_helpers.js';
+
+const _sockets = new Map();
+const _servers = new Map();
+let _nextId = 1;
+
+export const TlsFunctions = {
+
+    connect: (args) => {
+        requireArgs('tls.connect', args, 2);
+        const host = toStr(args[0]);
+        const port = toNum(args[1]);
+        const opts = args[2] && typeof args[2] === 'object' ? args[2] : {};
+        const id = `tls_${_nextId++}`;
+
+        const tlsOpts = {
+            host,
+            port,
+            rejectUnauthorized: opts.rejectUnauthorized !== false,
+        };
+
+        // Optional client certificates
+        if (opts.cert) tlsOpts.cert = readFileSync(resolve(toStr(opts.cert)));
+        if (opts.key) tlsOpts.key = readFileSync(resolve(toStr(opts.key)));
+        if (opts.ca) tlsOpts.ca = readFileSync(resolve(toStr(opts.ca)));
+        if (opts.servername) tlsOpts.servername = toStr(opts.servername);
+        if (opts.minVersion) tlsOpts.minVersion = toStr(opts.minVersion);
+        if (opts.maxVersion) tlsOpts.maxVersion = toStr(opts.maxVersion);
+
+        return new Promise((resolve, reject) => {
+            const socket = _tlsConnect(tlsOpts, () => {
+                _sockets.set(id, { socket, data: '' });
+                socket.on('data', (chunk) => {
+                    const entry = _sockets.get(id);
+                    if (entry) entry.data += chunk.toString();
+                });
+                socket.on('end', () => { _sockets.delete(id); });
+                socket.on('error', () => { _sockets.delete(id); });
+                resolve(id);
+            });
+            socket.on('error', (err) => reject(new Error(`tls.connect: ${err.message}`)));
+        });
+    },
+
+    send: (args) => {
+        requireArgs('tls.send', args, 2);
+        const id = toStr(args[0]);
+        const data = toStr(args[1]);
+        const entry = _sockets.get(id);
+        if (!entry) throw new Error(`tls.send: socket ${id} not found`);
+        return new Promise((resolve, reject) => {
+            entry.socket.write(data, (err) => {
+                if (err) reject(err);
+                else resolve(true);
+            });
+        });
+    },
+
+    read: (args) => {
+        requireArgs('tls.read', args, 1);
+        const id = toStr(args[0]);
+        const entry = _sockets.get(id);
+        if (!entry) throw new Error(`tls.read: socket ${id} not found`);
+        const data = entry.data;
+        entry.data = '';
+        return data;
+    },
+
+    close: (args) => {
+        requireArgs('tls.close', args, 1);
+        const id = toStr(args[0]);
+        const entry = _sockets.get(id);
+        if (entry) {
+            entry.socket.destroy();
+            _sockets.delete(id);
+            return true;
+        }
+        const server = _servers.get(id);
+        if (server) {
+            server.close();
+            _servers.delete(id);
+            return true;
+        }
+        return false;
+    },
+
+    createServer: (args, callback) => {
+        requireArgs('tls.createServer', args, 1);
+        const opts = args[0];
+        if (typeof opts !== 'object' || opts === null) {
+            throw new Error('tls.createServer requires options: {port, cert, key}');
+        }
+        const port = toNum(opts.port, 443);
+        const host = toStr(opts.host || '0.0.0.0');
+        const id = `tlss_${_nextId++}`;
+
+        const serverOpts = {};
+        if (opts.cert) serverOpts.cert = readFileSync(resolve(toStr(opts.cert)));
+        if (opts.key) serverOpts.key = readFileSync(resolve(toStr(opts.key)));
+        if (opts.ca) serverOpts.ca = readFileSync(resolve(toStr(opts.ca)));
+        if (opts.requestCert) serverOpts.requestCert = true;
+
+        const server = _tlsCreateServer(serverOpts, (socket) => {
+            const connId = `tlsc_${_nextId++}`;
+            _sockets.set(connId, { socket, data: '' });
+            socket.on('data', (chunk) => {
+                const entry = _sockets.get(connId);
+                if (entry) entry.data += chunk.toString();
+                if (callback) callback([connId, chunk.toString()]);
+            });
+            socket.on('end', () => { _sockets.delete(connId); });
+            socket.on('error', () => { _sockets.delete(connId); });
+        });
+
+        server.listen(port, host);
+        _servers.set(id, server);
+        return id;
+    },
+
+    getCertificate: (args) => {
+        requireArgs('tls.getCertificate', args, 1);
+        const id = toStr(args[0]);
+        const entry = _sockets.get(id);
+        if (!entry) throw new Error(`tls.getCertificate: socket ${id} not found`);
+        const cert = entry.socket.getPeerCertificate();
+        return {
+            subject: cert.subject,
+            issuer: cert.issuer,
+            validFrom: cert.valid_from,
+            validTo: cert.valid_to,
+            fingerprint: cert.fingerprint,
+            fingerprint256: cert.fingerprint256,
+            serialNumber: cert.serialNumber
+        };
+    },
+
+    getPeerCertificate: (args) => {
+        requireArgs('tls.getPeerCertificate', args, 1);
+        const id = toStr(args[0]);
+        const entry = _sockets.get(id);
+        if (!entry) throw new Error(`tls.getPeerCertificate: socket ${id} not found`);
+        const cert = entry.socket.getPeerCertificate(true);
+        return {
+            subject: cert.subject,
+            issuer: cert.issuer,
+            validFrom: cert.valid_from,
+            validTo: cert.valid_to,
+            fingerprint: cert.fingerprint,
+            fingerprint256: cert.fingerprint256,
+            serialNumber: cert.serialNumber,
+            raw: cert.raw ? cert.raw.toString('base64') : null
+        };
+    },
+
+    isEncrypted: (args) => {
+        requireArgs('tls.isEncrypted', args, 1);
+        const id = toStr(args[0]);
+        const entry = _sockets.get(id);
+        if (!entry) return false;
+        return entry.socket.encrypted === true;
+    },
+
+    getProtocol: (args) => {
+        requireArgs('tls.getProtocol', args, 1);
+        const id = toStr(args[0]);
+        const entry = _sockets.get(id);
+        if (!entry) throw new Error(`tls.getProtocol: socket ${id} not found`);
+        return entry.socket.getProtocol();
+    },
+
+    getCipher: (args) => {
+        requireArgs('tls.getCipher', args, 1);
+        const id = toStr(args[0]);
+        const entry = _sockets.get(id);
+        if (!entry) throw new Error(`tls.getCipher: socket ${id} not found`);
+        return entry.socket.getCipher();
+    },
+
+    active: () => ({
+        sockets: Array.from(_sockets.keys()),
+        servers: Array.from(_servers.keys())
+    })
+};
+
+export const TlsFunctionMetadata = {
+    connect: {
+        description: 'Create a TLS/SSL connection',
+        parameters: [
+            { name: 'host', dataType: 'string', description: 'Hostname', formInputType: 'text', required: true },
+            { name: 'port', dataType: 'number', description: 'Port number', formInputType: 'number', required: true },
+            { name: 'options', dataType: 'object', description: 'TLS options: cert, key, ca, rejectUnauthorized, servername', formInputType: 'json', required: false }
+        ],
+        returnType: 'string', returnDescription: 'TLS socket handle ID', example: 'tls.connect "smtp.gmail.com" 465'
+    },
+    send: {
+        description: 'Send data over TLS socket',
+        parameters: [
+            { name: 'socketId', dataType: 'string', description: 'Socket handle', formInputType: 'text', required: true },
+            { name: 'data', dataType: 'string', description: 'Data to send', formInputType: 'text', required: true }
+        ],
+        returnType: 'boolean', returnDescription: 'true on success', example: 'tls.send $sock "EHLO example.com"'
+    },
+    read: {
+        description: 'Read buffered TLS data',
+        parameters: [{ name: 'socketId', dataType: 'string', description: 'Socket handle', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'Buffered data', example: 'tls.read $sock'
+    },
+    close: {
+        description: 'Close TLS socket or server',
+        parameters: [{ name: 'id', dataType: 'string', description: 'Socket or server handle', formInputType: 'text', required: true }],
+        returnType: 'boolean', returnDescription: 'true if closed', example: 'tls.close $sock'
+    },
+    createServer: {
+        description: 'Create a TLS server',
+        parameters: [{ name: 'options', dataType: 'object', description: 'Server options: port, cert, key, ca', formInputType: 'json', required: true }],
+        returnType: 'string', returnDescription: 'Server handle ID', example: 'tls.createServer {"port": 443, "cert": "cert.pem", "key": "key.pem"}'
+    },
+    getCertificate: {
+        description: 'Get peer TLS certificate info',
+        parameters: [{ name: 'socketId', dataType: 'string', description: 'Socket handle', formInputType: 'text', required: true }],
+        returnType: 'object', returnDescription: 'Certificate details', example: 'tls.getCertificate $sock'
+    },
+    getPeerCertificate: {
+        description: 'Get full peer certificate with raw data',
+        parameters: [{ name: 'socketId', dataType: 'string', description: 'Socket handle', formInputType: 'text', required: true }],
+        returnType: 'object', returnDescription: 'Full certificate object', example: 'tls.getPeerCertificate $sock'
+    },
+    isEncrypted: {
+        description: 'Check if socket is TLS encrypted',
+        parameters: [{ name: 'socketId', dataType: 'string', description: 'Socket handle', formInputType: 'text', required: true }],
+        returnType: 'boolean', returnDescription: 'true if encrypted', example: 'tls.isEncrypted $sock'
+    },
+    getProtocol: {
+        description: 'Get TLS protocol version (e.g. TLSv1.3)',
+        parameters: [{ name: 'socketId', dataType: 'string', description: 'Socket handle', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'Protocol version string', example: 'tls.getProtocol $sock'
+    },
+    getCipher: {
+        description: 'Get current cipher info',
+        parameters: [{ name: 'socketId', dataType: 'string', description: 'Socket handle', formInputType: 'text', required: true }],
+        returnType: 'object', returnDescription: 'Cipher name and version', example: 'tls.getCipher $sock'
+    },
+    active: { description: 'List active TLS sockets and servers', parameters: [], returnType: 'object', returnDescription: '{sockets, servers}', example: 'tls.active' }
+};
+
+export const TlsModuleMetadata = {
+    description: 'TLS/SSL: secure connections, certificates, encrypted client/server sockets',
+    methods: Object.keys(TlsFunctions)
+};
+
+export default {
+    name: 'tls',
+    functions: TlsFunctions,
+    functionMetadata: TlsFunctionMetadata,
+    moduleMetadata: TlsModuleMetadata,
+    global: false
+};

package/modules/tty.js

@@ -0,0 +1,169 @@
+/**
+ * Native tty module for RobinPath.
+ * Terminal/TTY detection and capabilities — needed by supports-color, chalk, etc.
+ */
+import { isatty } from 'node:tty';
+import { toNum, requireArgs } from './_helpers.js';
+
+export const TtyFunctions = {
+
+    isatty: (args) => {
+        requireArgs('tty.isatty', args, 1);
+        const fd = toNum(args[0], 1);
+        return isatty(fd);
+    },
+
+    isStdinTTY: () => process.stdin?.isTTY === true,
+
+    isStdoutTTY: () => process.stdout?.isTTY === true,
+
+    isStderrTTY: () => process.stderr?.isTTY === true,
+
+    columns: () => process.stdout?.columns || 80,
+
+    rows: () => process.stdout?.rows || 24,
+
+    size: () => ({
+        columns: process.stdout?.columns || 80,
+        rows: process.stdout?.rows || 24
+    }),
+
+    hasColors: (args) => {
+        const count = args[0] ? toNum(args[0], 16) : 16;
+        if (process.stdout?.hasColors) {
+            return process.stdout.hasColors(count);
+        }
+        // Fallback: detect from env
+        const env = process.env;
+        if (env.NO_COLOR) return false;
+        if (env.FORCE_COLOR) return true;
+        if (env.TERM === 'dumb') return false;
+        if (process.platform === 'win32') return true;
+        if (env.CI) return true;
+        if (env.COLORTERM === 'truecolor' || env.COLORTERM === '24bit') return count <= 16777216;
+        if (env.TERM_PROGRAM === 'iTerm.app') return count <= 256;
+        if (/256color/i.test(env.TERM || '')) return count <= 256;
+        return count <= 16;
+    },
+
+    colorDepth: () => {
+        if (process.stdout?.getColorDepth) {
+            return process.stdout.getColorDepth();
+        }
+        const env = process.env;
+        if (env.NO_COLOR) return 1;
+        if (env.COLORTERM === 'truecolor' || env.COLORTERM === '24bit') return 24;
+        if (process.platform === 'win32') return 4;
+        if (/256color/i.test(env.TERM || '')) return 8;
+        return 4;
+    },
+
+    supportsColor: () => {
+        const env = process.env;
+        if (env.NO_COLOR) return false;
+        if (env.FORCE_COLOR) return true;
+        if (env.TERM === 'dumb') return false;
+        if (process.platform === 'win32') return true;
+        if (process.stdout?.isTTY) return true;
+        if (env.CI) return true;
+        return false;
+    },
+
+    getWindowSize: () => {
+        if (process.stdout?.getWindowSize) {
+            const [cols, rows] = process.stdout.getWindowSize();
+            return { columns: cols, rows };
+        }
+        return {
+            columns: process.stdout?.columns || 80,
+            rows: process.stdout?.rows || 24
+        };
+    },
+
+    clearLine: (args) => {
+        const dir = args[0] ? toNum(args[0], 0) : 0;
+        if (process.stdout?.clearLine) {
+            process.stdout.clearLine(dir);
+            return true;
+        }
+        return false;
+    },
+
+    cursorTo: (args) => {
+        requireArgs('tty.cursorTo', args, 1);
+        const x = toNum(args[0], 0);
+        const y = args[1] != null ? toNum(args[1]) : undefined;
+        if (process.stdout?.cursorTo) {
+            process.stdout.cursorTo(x, y);
+            return true;
+        }
+        return false;
+    },
+
+    moveCursor: (args) => {
+        requireArgs('tty.moveCursor', args, 2);
+        const dx = toNum(args[0], 0);
+        const dy = toNum(args[1], 0);
+        if (process.stdout?.moveCursor) {
+            process.stdout.moveCursor(dx, dy);
+            return true;
+        }
+        return false;
+    }
+};
+
+export const TtyFunctionMetadata = {
+    isatty: {
+        description: 'Check if a file descriptor is a TTY',
+        parameters: [{ name: 'fd', dataType: 'number', description: 'File descriptor (0=stdin, 1=stdout, 2=stderr)', formInputType: 'number', required: true }],
+        returnType: 'boolean', returnDescription: 'true if TTY', example: 'tty.isatty 1'
+    },
+    isStdinTTY: { description: 'Check if stdin is a TTY', parameters: [], returnType: 'boolean', returnDescription: 'true if TTY', example: 'tty.isStdinTTY' },
+    isStdoutTTY: { description: 'Check if stdout is a TTY', parameters: [], returnType: 'boolean', returnDescription: 'true if TTY', example: 'tty.isStdoutTTY' },
+    isStderrTTY: { description: 'Check if stderr is a TTY', parameters: [], returnType: 'boolean', returnDescription: 'true if TTY', example: 'tty.isStderrTTY' },
+    columns: { description: 'Get terminal width in columns', parameters: [], returnType: 'number', returnDescription: 'Column count', example: 'tty.columns' },
+    rows: { description: 'Get terminal height in rows', parameters: [], returnType: 'number', returnDescription: 'Row count', example: 'tty.rows' },
+    size: { description: 'Get terminal size {columns, rows}', parameters: [], returnType: 'object', returnDescription: '{columns, rows}', example: 'tty.size' },
+    hasColors: {
+        description: 'Check if terminal supports N colors',
+        parameters: [{ name: 'count', dataType: 'number', description: 'Number of colors to check (default: 16)', formInputType: 'number', required: false, defaultValue: '16' }],
+        returnType: 'boolean', returnDescription: 'true if supported', example: 'tty.hasColors 256'
+    },
+    colorDepth: { description: 'Get terminal color depth in bits', parameters: [], returnType: 'number', returnDescription: 'Color depth (1, 4, 8, or 24)', example: 'tty.colorDepth' },
+    supportsColor: { description: 'Check if terminal supports color output', parameters: [], returnType: 'boolean', returnDescription: 'true if color supported', example: 'tty.supportsColor' },
+    getWindowSize: { description: 'Get terminal window size', parameters: [], returnType: 'object', returnDescription: '{columns, rows}', example: 'tty.getWindowSize' },
+    clearLine: {
+        description: 'Clear the current terminal line',
+        parameters: [{ name: 'direction', dataType: 'number', description: '-1=left, 0=entire, 1=right', formInputType: 'number', required: false, defaultValue: '0' }],
+        returnType: 'boolean', returnDescription: 'true if cleared', example: 'tty.clearLine 0'
+    },
+    cursorTo: {
+        description: 'Move cursor to position',
+        parameters: [
+            { name: 'x', dataType: 'number', description: 'Column position', formInputType: 'number', required: true },
+            { name: 'y', dataType: 'number', description: 'Row position', formInputType: 'number', required: false }
+        ],
+        returnType: 'boolean', returnDescription: 'true if moved', example: 'tty.cursorTo 0 5'
+    },
+    moveCursor: {
+        description: 'Move cursor relative to current position',
+        parameters: [
+            { name: 'dx', dataType: 'number', description: 'Horizontal offset', formInputType: 'number', required: true },
+            { name: 'dy', dataType: 'number', description: 'Vertical offset', formInputType: 'number', required: true }
+        ],
+        returnType: 'boolean', returnDescription: 'true if moved', example: 'tty.moveCursor 1 -1'
+    }
+};
+
+export const TtyModuleMetadata = {
+    description: 'TTY: terminal detection, color support, cursor control, window size',
+    methods: Object.keys(TtyFunctions)
+};
+
+export default {
+    name: 'tty',
+    functions: TtyFunctions,
+    functionMetadata: TtyFunctionMetadata,
+    moduleMetadata: TtyModuleMetadata,
+    global: false
+};

package/modules/url.js

@@ -0,0 +1,189 @@
+/**
+ * Native URL module for RobinPath.
+ * URL parsing, formatting, and encoding utilities.
+ */
+import { toStr, requireArgs } from './_helpers.js';
+
+export const UrlFunctions = {
+
+    parse: (args) => {
+        requireArgs('url.parse', args, 1);
+        const urlStr = toStr(args[0]);
+        const u = new URL(urlStr);
+        return {
+            href: u.href,
+            protocol: u.protocol,
+            hostname: u.hostname,
+            host: u.host,
+            port: u.port || null,
+            pathname: u.pathname,
+            search: u.search,
+            hash: u.hash,
+            origin: u.origin,
+            username: u.username,
+            password: u.password
+        };
+    },
+
+    format: (args) => {
+        requireArgs('url.format', args, 1);
+        const obj = args[0];
+        if (typeof obj === 'string') return obj;
+        if (typeof obj !== 'object' || obj === null) {
+            throw new Error('url.format requires a URL object or string');
+        }
+        const u = new URL(obj.href || `${obj.protocol || 'https:'}//${obj.hostname || 'localhost'}`);
+        if (obj.port) u.port = String(obj.port);
+        if (obj.pathname) u.pathname = obj.pathname;
+        if (obj.search) u.search = obj.search;
+        if (obj.hash) u.hash = obj.hash;
+        if (obj.username) u.username = obj.username;
+        if (obj.password) u.password = obj.password;
+        return u.href;
+    },
+
+    resolve: (args) => {
+        requireArgs('url.resolve', args, 2);
+        const base = toStr(args[0]);
+        const relative = toStr(args[1]);
+        return new URL(relative, base).href;
+    },
+
+    searchParams: (args) => {
+        requireArgs('url.searchParams', args, 1);
+        const urlStr = toStr(args[0]);
+        const u = new URL(urlStr);
+        const result = {};
+        for (const [key, value] of u.searchParams) {
+            result[key] = value;
+        }
+        return result;
+    },
+
+    buildQuery: (args) => {
+        requireArgs('url.buildQuery', args, 1);
+        const obj = args[0];
+        if (typeof obj !== 'object' || obj === null) {
+            throw new Error('url.buildQuery requires an object');
+        }
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(obj)) {
+            params.append(key, String(value));
+        }
+        return params.toString();
+    },
+
+    encode: (args) => {
+        requireArgs('url.encode', args, 1);
+        return encodeURIComponent(toStr(args[0]));
+    },
+
+    decode: (args) => {
+        requireArgs('url.decode', args, 1);
+        return decodeURIComponent(toStr(args[0]));
+    },
+
+    encodeFull: (args) => {
+        requireArgs('url.encodeFull', args, 1);
+        return encodeURI(toStr(args[0]));
+    },
+
+    decodeFull: (args) => {
+        requireArgs('url.decodeFull', args, 1);
+        return decodeURI(toStr(args[0]));
+    },
+
+    isValid: (args) => {
+        requireArgs('url.isValid', args, 1);
+        try {
+            new URL(toStr(args[0]));
+            return true;
+        } catch {
+            return false;
+        }
+    },
+
+    join: (args) => {
+        requireArgs('url.join', args, 2);
+        const base = toStr(args[0]).replace(/\/+$/, '');
+        const parts = args.slice(1).map(a => toStr(a).replace(/^\/+|\/+$/g, ''));
+        return base + '/' + parts.join('/');
+    }
+};
+
+export const UrlFunctionMetadata = {
+    parse: {
+        description: 'Parse a URL into components',
+        parameters: [{ name: 'url', dataType: 'string', description: 'URL string', formInputType: 'text', required: true }],
+        returnType: 'object', returnDescription: 'Object with protocol, hostname, port, pathname, search, hash', example: 'url.parse "https://example.com/path?q=1"'
+    },
+    format: {
+        description: 'Format a URL object into a string',
+        parameters: [{ name: 'urlObject', dataType: 'object', description: 'URL components object', formInputType: 'json', required: true }],
+        returnType: 'string', returnDescription: 'Formatted URL string', example: 'url.format $urlObj'
+    },
+    resolve: {
+        description: 'Resolve a relative URL against a base',
+        parameters: [
+            { name: 'base', dataType: 'string', description: 'Base URL', formInputType: 'text', required: true },
+            { name: 'relative', dataType: 'string', description: 'Relative URL', formInputType: 'text', required: true }
+        ],
+        returnType: 'string', returnDescription: 'Resolved URL', example: 'url.resolve "https://example.com" "/path"'
+    },
+    searchParams: {
+        description: 'Extract query parameters as an object',
+        parameters: [{ name: 'url', dataType: 'string', description: 'URL string', formInputType: 'text', required: true }],
+        returnType: 'object', returnDescription: 'Key-value object of query parameters', example: 'url.searchParams "https://example.com?a=1&b=2"'
+    },
+    buildQuery: {
+        description: 'Build a query string from an object',
+        parameters: [{ name: 'params', dataType: 'object', description: 'Key-value pairs', formInputType: 'json', required: true }],
+        returnType: 'string', returnDescription: 'Query string (without ?)', example: 'url.buildQuery {"a": 1, "b": 2}'
+    },
+    encode: {
+        description: 'URL-encode a string component',
+        parameters: [{ name: 'value', dataType: 'string', description: 'String to encode', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'Encoded string', example: 'url.encode "hello world"'
+    },
+    decode: {
+        description: 'URL-decode a string component',
+        parameters: [{ name: 'value', dataType: 'string', description: 'String to decode', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'Decoded string', example: 'url.decode "hello%20world"'
+    },
+    encodeFull: {
+        description: 'Encode a full URI',
+        parameters: [{ name: 'uri', dataType: 'string', description: 'URI to encode', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'Encoded URI', example: 'url.encodeFull "https://example.com/path with spaces"'
+    },
+    decodeFull: {
+        description: 'Decode a full URI',
+        parameters: [{ name: 'uri', dataType: 'string', description: 'URI to decode', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'Decoded URI', example: 'url.decodeFull "https://example.com/path%20with%20spaces"'
+    },
+    isValid: {
+        description: 'Check if a string is a valid URL',
+        parameters: [{ name: 'url', dataType: 'string', description: 'String to check', formInputType: 'text', required: true }],
+        returnType: 'boolean', returnDescription: 'true if valid URL', example: 'url.isValid "https://example.com"'
+    },
+    join: {
+        description: 'Join URL path segments',
+        parameters: [
+            { name: 'base', dataType: 'string', description: 'Base URL', formInputType: 'text', required: true },
+            { name: 'segments', dataType: 'string', description: 'Path segments', formInputType: 'text', required: true }
+        ],
+        returnType: 'string', returnDescription: 'Joined URL', example: 'url.join "https://api.example.com" "v1" "users"'
+    }
+};
+
+export const UrlModuleMetadata = {
+    description: 'URL parsing, formatting, encoding, and query string utilities',
+    methods: Object.keys(UrlFunctions)
+};
+
+export default {
+    name: 'url',
+    functions: UrlFunctions,
+    functionMetadata: UrlFunctionMetadata,
+    moduleMetadata: UrlModuleMetadata,
+    global: false
+};