@robinpath/cli 1.73.0

package/modules/http.js

@@ -0,0 +1,268 @@
+/**
+ * Native HTTP module for RobinPath.
+ * HTTP client (fetch-based) and server (Node.js http).
+ */
+import { createServer } from 'node:http';
+import { toStr, toNum, requireArgs } from './_helpers.js';
+
+const _servers = new Map();
+let _nextId = 1;
+
+async function doFetch(url, method, bodyArg, headersArg) {
+    const opts = { method };
+
+    // Headers
+    const headers = {};
+    if (headersArg && typeof headersArg === 'object') {
+        for (const [k, v] of Object.entries(headersArg)) headers[k] = toStr(v);
+    }
+
+    // Body
+    if (bodyArg != null && method !== 'GET' && method !== 'HEAD') {
+        if (typeof bodyArg === 'object') {
+            headers['Content-Type'] = headers['Content-Type'] || 'application/json';
+            opts.body = JSON.stringify(bodyArg);
+        } else {
+            opts.body = toStr(bodyArg);
+        }
+    }
+
+    opts.headers = headers;
+
+    const res = await fetch(url, opts);
+    const contentType = res.headers.get('content-type') || '';
+    let data;
+    if (contentType.includes('application/json')) {
+        try { data = await res.json(); } catch { data = await res.text(); }
+    } else {
+        data = await res.text();
+    }
+
+    return {
+        status: res.status,
+        statusText: res.statusText,
+        headers: Object.fromEntries(res.headers.entries()),
+        data,
+        ok: res.ok,
+        url: res.url
+    };
+}
+
+export const HttpFunctions = {
+
+    get: async (args) => {
+        requireArgs('http.get', args, 1);
+        return doFetch(toStr(args[0]), 'GET', null, args[1]);
+    },
+
+    post: async (args) => {
+        requireArgs('http.post', args, 1);
+        return doFetch(toStr(args[0]), 'POST', args[1], args[2]);
+    },
+
+    put: async (args) => {
+        requireArgs('http.put', args, 1);
+        return doFetch(toStr(args[0]), 'PUT', args[1], args[2]);
+    },
+
+    patch: async (args) => {
+        requireArgs('http.patch', args, 1);
+        return doFetch(toStr(args[0]), 'PATCH', args[1], args[2]);
+    },
+
+    delete: async (args) => {
+        requireArgs('http.delete', args, 1);
+        return doFetch(toStr(args[0]), 'DELETE', args[1], args[2]);
+    },
+
+    head: async (args) => {
+        requireArgs('http.head', args, 1);
+        const res = await fetch(toStr(args[0]), { method: 'HEAD' });
+        return {
+            status: res.status,
+            statusText: res.statusText,
+            headers: Object.fromEntries(res.headers.entries()),
+            ok: res.ok
+        };
+    },
+
+    request: async (args) => {
+        requireArgs('http.request', args, 1);
+        const opts = args[0];
+        if (typeof opts !== 'object' || opts === null) {
+            throw new Error('http.request requires an options object: {url, method, body?, headers?}');
+        }
+        const url = toStr(opts.url || opts.href);
+        const method = toStr(opts.method || 'GET').toUpperCase();
+        return doFetch(url, method, opts.body || opts.data, opts.headers);
+    },
+
+    serve: (args, callback) => {
+        requireArgs('http.serve', args, 1);
+        const port = toNum(args[0], 3000);
+        const host = toStr(args[1], '0.0.0.0');
+        const id = `http_${_nextId++}`;
+
+        const server = createServer(async (req, res) => {
+            const body = await new Promise((resolve) => {
+                let data = '';
+                req.on('data', (chunk) => { data += chunk; });
+                req.on('end', () => resolve(data));
+            });
+
+            let parsedBody = body;
+            try { parsedBody = JSON.parse(body); } catch { /* raw string */ }
+
+            const request = {
+                method: req.method,
+                url: req.url,
+                headers: req.headers,
+                body: parsedBody
+            };
+
+            if (callback) {
+                try {
+                    const result = await callback([request]);
+                    const statusCode = (result && result.status) ? result.status : 200;
+                    const respHeaders = (result && result.headers) ? result.headers : { 'Content-Type': 'application/json' };
+                    const respBody = (result && result.body != null) ? result.body : result;
+                    res.writeHead(statusCode, respHeaders);
+                    res.end(typeof respBody === 'object' ? JSON.stringify(respBody) : toStr(respBody));
+                } catch (err) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            } else {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(request));
+            }
+        });
+
+        server.listen(port, host);
+        _servers.set(id, server);
+        return id;
+    },
+
+    close: (args) => {
+        requireArgs('http.close', args, 1);
+        const id = toStr(args[0]);
+        const server = _servers.get(id);
+        if (server) {
+            server.close();
+            _servers.delete(id);
+            return true;
+        }
+        return false;
+    },
+
+    servers: () => Array.from(_servers.keys()),
+
+    download: async (args) => {
+        requireArgs('http.download', args, 2);
+        const url = toStr(args[0]);
+        const filePath = toStr(args[1]);
+        const res = await fetch(url);
+        if (!res.ok) throw new Error(`http.download: ${res.status} ${res.statusText}`);
+        const { writeFile } = await import('node:fs/promises');
+        const { resolve } = await import('node:path');
+        const buffer = Buffer.from(await res.arrayBuffer());
+        await writeFile(resolve(filePath), buffer);
+        return { size: buffer.length, path: filePath, status: res.status };
+    }
+};
+
+export const HttpFunctionMetadata = {
+    get: {
+        description: 'HTTP GET request',
+        parameters: [
+            { name: 'url', dataType: 'string', description: 'URL to request', formInputType: 'text', required: true },
+            { name: 'headers', dataType: 'object', description: 'Request headers', formInputType: 'json', required: false }
+        ],
+        returnType: 'object', returnDescription: 'Response with status, headers, data', example: 'http.get "https://api.example.com/data"'
+    },
+    post: {
+        description: 'HTTP POST request',
+        parameters: [
+            { name: 'url', dataType: 'string', description: 'URL', formInputType: 'text', required: true },
+            { name: 'body', dataType: 'any', description: 'Request body (object auto-serialized to JSON)', formInputType: 'json', required: false },
+            { name: 'headers', dataType: 'object', description: 'Request headers', formInputType: 'json', required: false }
+        ],
+        returnType: 'object', returnDescription: 'Response with status, headers, data', example: 'http.post "https://api.example.com/data" {"key": "value"}'
+    },
+    put: {
+        description: 'HTTP PUT request',
+        parameters: [
+            { name: 'url', dataType: 'string', description: 'URL', formInputType: 'text', required: true },
+            { name: 'body', dataType: 'any', description: 'Request body', formInputType: 'json', required: false },
+            { name: 'headers', dataType: 'object', description: 'Headers', formInputType: 'json', required: false }
+        ],
+        returnType: 'object', returnDescription: 'Response', example: 'http.put "https://api.example.com/data/1" {"key": "new"}'
+    },
+    patch: {
+        description: 'HTTP PATCH request',
+        parameters: [
+            { name: 'url', dataType: 'string', description: 'URL', formInputType: 'text', required: true },
+            { name: 'body', dataType: 'any', description: 'Request body', formInputType: 'json', required: false },
+            { name: 'headers', dataType: 'object', description: 'Headers', formInputType: 'json', required: false }
+        ],
+        returnType: 'object', returnDescription: 'Response', example: 'http.patch "https://api.example.com/data/1" {"key": "updated"}'
+    },
+    delete: {
+        description: 'HTTP DELETE request',
+        parameters: [
+            { name: 'url', dataType: 'string', description: 'URL', formInputType: 'text', required: true },
+            { name: 'body', dataType: 'any', description: 'Request body', formInputType: 'json', required: false },
+            { name: 'headers', dataType: 'object', description: 'Headers', formInputType: 'json', required: false }
+        ],
+        returnType: 'object', returnDescription: 'Response', example: 'http.delete "https://api.example.com/data/1"'
+    },
+    head: {
+        description: 'HTTP HEAD request (headers only)',
+        parameters: [{ name: 'url', dataType: 'string', description: 'URL', formInputType: 'text', required: true }],
+        returnType: 'object', returnDescription: 'Response with status and headers', example: 'http.head "https://example.com"'
+    },
+    request: {
+        description: 'Custom HTTP request with full options',
+        parameters: [{ name: 'options', dataType: 'object', description: 'Object with url, method, body, headers', formInputType: 'json', required: true }],
+        returnType: 'object', returnDescription: 'Response', example: 'http.request {"url": "https://api.example.com", "method": "POST", "body": {"key": 1}}'
+    },
+    serve: {
+        description: 'Start an HTTP server',
+        parameters: [
+            { name: 'port', dataType: 'number', description: 'Port to listen on (default: 3000)', formInputType: 'number', required: true },
+            { name: 'host', dataType: 'string', description: 'Host (default: 0.0.0.0)', formInputType: 'text', required: false, defaultValue: '0.0.0.0' }
+        ],
+        returnType: 'string', returnDescription: 'Server handle ID', example: 'http.serve 8080'
+    },
+    close: {
+        description: 'Close an HTTP server',
+        parameters: [{ name: 'serverId', dataType: 'string', description: 'Server handle ID', formInputType: 'text', required: true }],
+        returnType: 'boolean', returnDescription: 'true if closed', example: 'http.close $serverId'
+    },
+    servers: {
+        description: 'List all running HTTP servers',
+        parameters: [],
+        returnType: 'array', returnDescription: 'Array of server IDs', example: 'http.servers'
+    },
+    download: {
+        description: 'Download a file from a URL',
+        parameters: [
+            { name: 'url', dataType: 'string', description: 'URL to download', formInputType: 'text', required: true },
+            { name: 'path', dataType: 'string', description: 'Local file path to save', formInputType: 'text', required: true }
+        ],
+        returnType: 'object', returnDescription: 'Object with size, path, status', example: 'http.download "https://example.com/file.zip" "file.zip"'
+    }
+};
+
+export const HttpModuleMetadata = {
+    description: 'HTTP client and server: GET, POST, PUT, DELETE, serve, download',
+    methods: Object.keys(HttpFunctions)
+};
+
+export default {
+    name: 'http',
+    functions: HttpFunctions,
+    functionMetadata: HttpFunctionMetadata,
+    moduleMetadata: HttpModuleMetadata,
+    global: false
+};

package/modules/index.js

@@ -0,0 +1,76 @@
+/**
+ * RobinPath Native Modules — Barrel Export
+ * All modules listed here are bundled into the CLI binary.
+ */
+
+// Phase 1: Core System
+import FileModule from './file.js';
+import PathModule from './path.js';
+import ProcessModule from './process.js';
+import OsModule from './os.js';
+
+// Phase 2: Data & Security
+import CryptoModule from './crypto.js';
+import BufferModule from './buffer.js';
+import UrlModule from './url.js';
+import ChildModule from './child.js';
+import TimerModule from './timer.js';
+
+// Phase 3a: Networking & I/O
+import HttpModule from './http.js';
+import NetModule from './net.js';
+import DnsModule from './dns.js';
+import EventsModule from './events.js';
+import ZlibModule from './zlib.js';
+
+// Phase 3b: Streams, TLS & Utilities
+import StreamModule from './stream.js';
+import TlsModule from './tls.js';
+import UtilModule from './util.js';
+import AssertModule from './assert.js';
+import StringDecoderModule from './string_decoder.js';
+import TtyModule from './tty.js';
+
+// Phase 4: Document & Format Generation (uncomment as implemented)
+// import ArchiveModule from './archive.js';
+// import EmailModule from './email.js';
+// import BarcodeModule from './barcode.js';
+// import PdfModule from './pdf.js';
+// import ExcelModule from './excel.js';
+
+export const nativeModules = [
+    // Phase 1: Core System
+    FileModule,
+    PathModule,
+    ProcessModule,
+    OsModule,
+
+    // Phase 2: Data & Security
+    CryptoModule,
+    BufferModule,
+    UrlModule,
+    ChildModule,
+    TimerModule,
+
+    // Phase 3a: Networking & I/O
+    HttpModule,
+    NetModule,
+    DnsModule,
+    EventsModule,
+    ZlibModule,
+
+    // Phase 3b: Streams, TLS & Utilities
+    StreamModule,
+    TlsModule,
+    UtilModule,
+    AssertModule,
+    StringDecoderModule,
+    TtyModule,
+
+    // Phase 4
+    // ArchiveModule,
+    // EmailModule,
+    // BarcodeModule,
+    // PdfModule,
+    // ExcelModule,
+];

package/modules/net.js

@@ -0,0 +1,189 @@
+/**
+ * Native net module for RobinPath.
+ * TCP client/server and socket operations.
+ */
+import { createServer, createConnection, isIP, isIPv4, isIPv6 } from 'node:net';
+import { toStr, toNum, requireArgs } from './_helpers.js';
+
+const _servers = new Map();
+const _sockets = new Map();
+let _nextId = 1;
+
+export const NetFunctions = {
+
+    connect: (args) => {
+        requireArgs('net.connect', args, 2);
+        const host = toStr(args[0]);
+        const port = toNum(args[1]);
+        const id = `sock_${_nextId++}`;
+
+        return new Promise((resolve, reject) => {
+            const socket = createConnection({ host, port }, () => {
+                _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(`net.connect: ${err.message}`)));
+        });
+    },
+
+    send: (args) => {
+        requireArgs('net.send', args, 2);
+        const id = toStr(args[0]);
+        const data = toStr(args[1]);
+        const entry = _sockets.get(id);
+        if (!entry) throw new Error(`net.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('net.read', args, 1);
+        const id = toStr(args[0]);
+        const entry = _sockets.get(id);
+        if (!entry) throw new Error(`net.read: socket ${id} not found`);
+        const data = entry.data;
+        entry.data = '';
+        return data;
+    },
+
+    close: (args) => {
+        requireArgs('net.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('net.createServer', args, 1);
+        const port = toNum(args[0]);
+        const host = toStr(args[1], '0.0.0.0');
+        const serverId = `tcp_${_nextId++}`;
+
+        const server = createServer((socket) => {
+            const connId = `conn_${_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(serverId, server);
+        return serverId;
+    },
+
+    isIP: (args) => {
+        requireArgs('net.isIP', args, 1);
+        return isIP(toStr(args[0]));
+    },
+
+    isIPv4: (args) => {
+        requireArgs('net.isIPv4', args, 1);
+        return isIPv4(toStr(args[0]));
+    },
+
+    isIPv6: (args) => {
+        requireArgs('net.isIPv6', args, 1);
+        return isIPv6(toStr(args[0]));
+    },
+
+    active: () => ({
+        servers: Array.from(_servers.keys()),
+        sockets: Array.from(_sockets.keys())
+    })
+};
+
+export const NetFunctionMetadata = {
+    connect: {
+        description: 'Connect to a TCP server',
+        parameters: [
+            { name: 'host', dataType: 'string', description: 'Host to connect to', formInputType: 'text', required: true },
+            { name: 'port', dataType: 'number', description: 'Port number', formInputType: 'number', required: true }
+        ],
+        returnType: 'string', returnDescription: 'Socket handle ID', example: 'net.connect "localhost" 8080'
+    },
+    send: {
+        description: 'Send data through a socket',
+        parameters: [
+            { name: 'socketId', dataType: 'string', description: 'Socket handle ID', formInputType: 'text', required: true },
+            { name: 'data', dataType: 'string', description: 'Data to send', formInputType: 'text', required: true }
+        ],
+        returnType: 'boolean', returnDescription: 'true on success', example: 'net.send $sock "hello"'
+    },
+    read: {
+        description: 'Read buffered data from a socket',
+        parameters: [{ name: 'socketId', dataType: 'string', description: 'Socket handle ID', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'Buffered data', example: 'net.read $sock'
+    },
+    close: {
+        description: 'Close a socket or server',
+        parameters: [{ name: 'id', dataType: 'string', description: 'Socket or server handle ID', formInputType: 'text', required: true }],
+        returnType: 'boolean', returnDescription: 'true if closed', example: 'net.close $sock'
+    },
+    createServer: {
+        description: 'Create a TCP server',
+        parameters: [
+            { name: 'port', dataType: 'number', description: 'Port to listen on', formInputType: 'number', required: true },
+            { name: 'host', dataType: 'string', description: 'Host (default: 0.0.0.0)', formInputType: 'text', required: false, defaultValue: '0.0.0.0' }
+        ],
+        returnType: 'string', returnDescription: 'Server handle ID', example: 'net.createServer 9090'
+    },
+    isIP: {
+        description: 'Check if string is a valid IP (returns 0, 4, or 6)',
+        parameters: [{ name: 'address', dataType: 'string', description: 'Address to check', formInputType: 'text', required: true }],
+        returnType: 'number', returnDescription: '0 (invalid), 4 (IPv4), or 6 (IPv6)', example: 'net.isIP "192.168.1.1"'
+    },
+    isIPv4: {
+        description: 'Check if string is a valid IPv4 address',
+        parameters: [{ name: 'address', dataType: 'string', description: 'Address', formInputType: 'text', required: true }],
+        returnType: 'boolean', returnDescription: 'true if IPv4', example: 'net.isIPv4 "192.168.1.1"'
+    },
+    isIPv6: {
+        description: 'Check if string is a valid IPv6 address',
+        parameters: [{ name: 'address', dataType: 'string', description: 'Address', formInputType: 'text', required: true }],
+        returnType: 'boolean', returnDescription: 'true if IPv6', example: 'net.isIPv6 "::1"'
+    },
+    active: {
+        description: 'List active servers and sockets',
+        parameters: [],
+        returnType: 'object', returnDescription: 'Object with servers and sockets arrays', example: 'net.active'
+    }
+};
+
+export const NetModuleMetadata = {
+    description: 'TCP networking: connect, send, read, createServer, and IP utilities',
+    methods: Object.keys(NetFunctions)
+};
+
+export default {
+    name: 'net',
+    functions: NetFunctions,
+    functionMetadata: NetFunctionMetadata,
+    moduleMetadata: NetModuleMetadata,
+    global: false
+};