@nimbus-sh/core 0.1.0

package/dist/substrate/lifo/commands/net/ports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ports.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/net/ports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAqC1D"}

package/dist/substrate/lifo/commands/net/ports.js

@@ -0,0 +1,36 @@
+/**
+ * ports - List all ports in the portRegistry with details
+ * Usage: ports
+ */
+export function createPortsCommand(kernel) {
+    return async (ctx) => {
+        // Debug: Show kernel info
+        const hasRegistry = !!kernel.portRegistry;
+        const registrySize = hasRegistry ? kernel.portRegistry.size : 0;
+        ctx.stdout.write(`\x1b[90m[Debug] Kernel has portRegistry: ${hasRegistry}\x1b[0m\n`);
+        ctx.stdout.write(`\x1b[90m[Debug] Registry size: ${registrySize}\x1b[0m\n`);
+        ctx.stdout.write(`\x1b[90m[Debug] Registry instance: ${kernel.portRegistry ? 'Map' : 'undefined'}\x1b[0m\n\n`);
+        const ports = Array.from(kernel.portRegistry.entries()).sort((a, b) => a[0] - b[0]);
+        if (ports.length === 0) {
+            ctx.stdout.write('No ports registered in portRegistry\n');
+            ctx.stdout.write('\nDiagnostic steps:\n');
+            ctx.stdout.write('  1. Run: node test-server.js\n');
+            ctx.stdout.write('  2. Look for "[lifo-http] Server listening on port 3000"\n');
+            ctx.stdout.write('  3. Run: ports (in the SAME tab)\n');
+            ctx.stdout.write('  4. If still empty, there may be an error during server creation\n');
+            return 0;
+        }
+        ctx.stdout.write('Registered ports in portRegistry:\n\n');
+        ctx.stdout.write('Port   Handler   Description\n');
+        ctx.stdout.write('-----  --------  -----------\n');
+        for (const [port, handler] of ports) {
+            const handlerStr = '\x1b[32m✓\x1b[0m    ';
+            const handlerType = typeof handler;
+            const desc = `Active (handler: ${handlerType})`;
+            ctx.stdout.write(`${String(port).padEnd(6)} ${handlerStr}  ${desc}\n`);
+        }
+        ctx.stdout.write(`\nTotal: ${ports.length} port(s)\n`);
+        ctx.stdout.write(`\nAccess: curl localhost:PORT or /api/proxy/PORT/ in browser\n`);
+        return 0;
+    };
+}

package/dist/substrate/lifo/commands/net/route.d.ts

@@ -0,0 +1,8 @@
+import type { Command } from '../types.js';
+import type { Kernel } from '../../kernel/index.js';
+/**
+ * route - Show/manipulate IP routing table
+ * Usage: route [-n] [add|del] [destination] [gw gateway] [dev interface]
+ */
+export declare function createRouteCommand(kernel: Kernel): Command;
+//# sourceMappingURL=route.d.ts.map

package/dist/substrate/lifo/commands/net/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/net/route.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CA0B1D"}

package/dist/substrate/lifo/commands/net/route.js

@@ -0,0 +1,128 @@
+/**
+ * route - Show/manipulate IP routing table
+ * Usage: route [-n] [add|del] [destination] [gw gateway] [dev interface]
+ */
+export function createRouteCommand(kernel) {
+    return async (ctx) => {
+        const args = ctx.args;
+        // No arguments: show routing table
+        if (args.length === 0 || args[0] === '-n') {
+            const table = kernel.networkStack.getRoutingTableString();
+            ctx.stdout.write(table + '\n');
+            return 0;
+        }
+        const command = args[0];
+        switch (command) {
+            case 'add':
+                return addRoute(ctx, args.slice(1), kernel.networkStack);
+            case 'del':
+            case 'delete':
+                return deleteRoute(ctx, args.slice(1), kernel.networkStack);
+            default:
+                ctx.stderr.write('Usage: route [-n] [add|del] [destination] [gw gateway] [dev interface]\n');
+                return 1;
+        }
+    };
+}
+/**
+ * Add route to routing table
+ */
+function addRoute(ctx, args, networkStack) {
+    if (args.length < 2) {
+        ctx.stderr.write('Usage: route add <destination> [gw <gateway>] dev <interface>\n');
+        return 1;
+    }
+    let destination = args[0];
+    let gateway;
+    let iface;
+    let metric = 0;
+    // Parse arguments
+    let i = 1;
+    while (i < args.length) {
+        const arg = args[i];
+        if (arg === 'gw') {
+            gateway = args[i + 1];
+            i += 2;
+        }
+        else if (arg === 'dev') {
+            iface = args[i + 1];
+            i += 2;
+        }
+        else if (arg === 'metric') {
+            metric = parseInt(args[i + 1], 10) || 0;
+            i += 2;
+        }
+        else {
+            i++;
+        }
+    }
+    if (!iface) {
+        ctx.stderr.write('route: interface required (use "dev <interface>")\n');
+        return 1;
+    }
+    // Handle special destinations
+    if (destination === 'default') {
+        destination = '0.0.0.0/0';
+    }
+    else if (!destination.includes('/')) {
+        destination += '/32'; // Single host
+    }
+    try {
+        networkStack.addRoute({
+            destination,
+            gateway,
+            interface: iface,
+            metric,
+            namespace: 'default',
+        });
+        ctx.stdout.write(`Route added: ${destination} via ${gateway || '*'} dev ${iface}\n`);
+        return 0;
+    }
+    catch (error) {
+        ctx.stderr.write(`route: ${error instanceof Error ? error.message : String(error)}\n`);
+        return 1;
+    }
+}
+/**
+ * Delete route from routing table
+ */
+function deleteRoute(ctx, args, networkStack) {
+    if (args.length < 2) {
+        ctx.stderr.write('Usage: route del <destination> dev <interface>\n');
+        return 1;
+    }
+    let destination = args[0];
+    let iface;
+    // Parse arguments
+    let i = 1;
+    while (i < args.length) {
+        const arg = args[i];
+        if (arg === 'dev') {
+            iface = args[i + 1];
+            i += 2;
+        }
+        else {
+            i++;
+        }
+    }
+    if (!iface) {
+        ctx.stderr.write('route: interface required (use "dev <interface>")\n');
+        return 1;
+    }
+    // Handle special destinations
+    if (destination === 'default') {
+        destination = '0.0.0.0/0';
+    }
+    else if (!destination.includes('/')) {
+        destination += '/32';
+    }
+    const removed = networkStack.removeRoute(destination, iface);
+    if (removed) {
+        ctx.stdout.write(`Route deleted: ${destination} dev ${iface}\n`);
+        return 0;
+    }
+    else {
+        ctx.stderr.write(`route: no such route\n`);
+        return 1;
+    }
+}

package/dist/substrate/lifo/commands/net/tunnel-v2.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from '../types.js';
+import type { Kernel } from '../../kernel/index.js';
+export declare function createTunnelCommandV2(kernel: Kernel): Command;
+//# sourceMappingURL=tunnel-v2.d.ts.map

package/dist/substrate/lifo/commands/net/tunnel-v2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tunnel-v2.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/net/tunnel-v2.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AA+CpD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAsI7D"}

package/dist/substrate/lifo/commands/net/tunnel-v2.js

@@ -0,0 +1,141 @@
+import { WebSocketTunnel } from '../../kernel/network/tunnel/WebSocketTunnel.js';
+import { waitForAbort } from '../signal.js';
+function parseArgs(args) {
+    let server = 'ws://localhost:3005';
+    let port = null;
+    let verbose = false;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--help' || args[i] === '-h') {
+            return { help: true };
+        }
+        else if (args[i].startsWith('--server=')) {
+            server = args[i].slice('--server='.length);
+        }
+        else if (args[i] === '--server' && args[i + 1]) {
+            server = args[++i];
+        }
+        else if (args[i].startsWith('--port=')) {
+            port = parseInt(args[i].slice('--port='.length), 10);
+        }
+        else if ((args[i] === '--port' || args[i] === '-p') && args[i + 1]) {
+            port = parseInt(args[++i], 10);
+        }
+        else if (args[i] === '-v' || args[i] === '--verbose') {
+            verbose = true;
+        }
+    }
+    return { server, port, verbose };
+}
+export function createTunnelCommandV2(kernel) {
+    return async (ctx) => {
+        const options = parseArgs(ctx.args);
+        // Handle --help
+        if ('help' in options && options.help) {
+            ctx.stdout.write(`Usage: tunnel [options]
+
+Expose Lifo HTTP servers through a WebSocket tunnel
+
+Options:
+  --server <url>    Tunnel server URL (default: ws://localhost:3005)
+  --port, -p <num>  Default port (routes all requests to this port)
+  -v, --verbose     Verbose logging
+  -h, --help        Show this help
+
+Examples:
+  # Path-based routing (default):
+  tunnel
+  # Access: http://localhost:3005/3000/ → Port 3000
+  #         http://localhost:3005/8080/ → Port 8080
+
+  # Default port mode (for Vite, webpack-dev-server, etc.):
+  tunnel --port 5173
+  # Access: http://localhost:3005/ → Port 5173
+
+Without --port, uses path-based routing:
+  http://localhost:3005/3000/         → Port 3000 inside Lifo
+  http://localhost:3005/8080/api      → Port 8080, path /api
+  http://localhost:3005/3000/users    → Port 3000, path /users
+
+With --port 5173:
+  http://localhost:3005/              → Port 5173, path /
+  http://localhost:3005/src/main.ts   → Port 5173, path /src/main.ts
+  (Perfect for Vite dev server!)\n`);
+            return 0;
+        }
+        const { server, port: defaultPort, verbose } = options;
+        function log(message) {
+            if (verbose) {
+                ctx.stdout.write(`[tunnel] ${message}\n`);
+            }
+        }
+        // Check if tunnel already exists
+        const existingTunnel = kernel.networkStack.getTunnel('wst0');
+        if (existingTunnel) {
+            ctx.stderr.write('Tunnel already active. Use Ctrl+C to stop it first.\n');
+            return 1;
+        }
+        // Create WebSocket tunnel
+        const tunnelId = kernel.networkStack.getNextTunnelId();
+        const tunnel = new WebSocketTunnel(tunnelId, server, kernel.networkStack, kernel.portRegistry, 'default', defaultPort);
+        ctx.stdout.write(`Connecting to tunnel server at ${server}...\n`);
+        log('Creating WebSocket tunnel');
+        try {
+            // Add tunnel to network stack
+            kernel.networkStack.addTunnel('wst0', tunnel);
+            // Bring tunnel up (connects WebSocket)
+            await tunnel.up();
+            ctx.stdout.write(`✓ Connected to tunnel server\n`);
+            const httpUrl = server.replace('ws://', 'http://').replace('wss://', 'https://');
+            if (defaultPort) {
+                ctx.stdout.write(`Tunnel ready — all traffic → port ${defaultPort}\n`);
+                ctx.stdout.write(`  Open: ${httpUrl}\n`);
+            }
+            else {
+                ctx.stdout.write(`Tunnel ready at ${httpUrl}\n`);
+                // Show active ports
+                const ports = tunnel.getActivePorts();
+                if (ports.length === 0) {
+                    ctx.stdout.write('\nNo active servers to tunnel\n');
+                    ctx.stdout.write('Start a server first: node server.js\n');
+                }
+                else {
+                    ctx.stdout.write(`\nTunneling ${ports.length} server(s):\n`);
+                    for (const port of ports) {
+                        ctx.stdout.write(`  - Port ${port}: ${httpUrl}/${port}/\n`);
+                    }
+                }
+            }
+            ctx.stdout.write('\nPress Ctrl+C to stop tunnel\n\n');
+            log('Tunnel is active');
+            // Monitor connection status
+            const checkInterval = setInterval(() => {
+                if (!tunnel.isConnected()) {
+                    log('Connection lost, reconnecting...');
+                }
+                else {
+                    log('Connection active');
+                }
+            }, verbose ? 10000 : 60000);
+            await waitForAbort(ctx.signal);
+            clearInterval(checkInterval);
+            ctx.stdout.write('\nShutting down tunnel...\n');
+            await tunnel.down();
+            await kernel.networkStack.removeTunnel('wst0');
+            ctx.stdout.write('Tunnel closed\n');
+            return 0;
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            ctx.stderr.write(`tunnel: ${msg}\n`);
+            // Cleanup on error
+            try {
+                await tunnel.down();
+                await kernel.networkStack.removeTunnel('wst0');
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            return 1;
+        }
+    };
+}

package/dist/substrate/lifo/commands/net/tunnel.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from '../types.js';
+import type { Kernel } from '../../kernel/index.js';
+export declare function createTunnelCommand(kernel: Kernel): Command;
+declare const command: Command;
+export default command;
+//# sourceMappingURL=tunnel.d.ts.map

package/dist/substrate/lifo/commands/net/tunnel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tunnel.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/net/tunnel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAuQpD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE3D;AAGD,QAAA,MAAM,OAAO,EAAE,OAA4B,CAAC;AAE5C,eAAe,OAAO,CAAC"}

package/dist/substrate/lifo/commands/net/tunnel.js

@@ -0,0 +1,232 @@
+import { Buffer } from '../../node-compat/buffer.js';
+import { waitForAbort, waitForSignalOrTimeout } from '../signal.js';
+function parseArgs(args) {
+    let server = 'ws://localhost:3005';
+    let port = null;
+    let verbose = false;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--help' || args[i] === '-h') {
+            return { help: true };
+        }
+        else if (args[i].startsWith('--server=')) {
+            server = args[i].slice('--server='.length);
+        }
+        else if (args[i] === '--server' && args[i + 1]) {
+            server = args[++i];
+        }
+        else if (args[i].startsWith('--port=')) {
+            port = parseInt(args[i].slice('--port='.length), 10);
+        }
+        else if ((args[i] === '--port' || args[i] === '-p') && args[i + 1]) {
+            port = parseInt(args[++i], 10);
+        }
+        else if (args[i] === '-v' || args[i] === '--verbose') {
+            verbose = true;
+        }
+    }
+    return { server, port, verbose };
+}
+function createTunnelImpl(kernel) {
+    return async (ctx) => {
+        const options = parseArgs(ctx.args);
+        // Handle --help
+        if ('help' in options && options.help) {
+            ctx.stdout.write('Usage: tunnel [options]\n\n');
+            ctx.stdout.write('Expose Lifo HTTP servers through a tunnel\n\n');
+            ctx.stdout.write('Options:\n');
+            ctx.stdout.write('  --server <url>    Tunnel server URL (default: ws://localhost:3005)\n');
+            ctx.stdout.write('  --port, -p <num>  Default port (routes all requests to this port)\n');
+            ctx.stdout.write('  -v, --verbose     Verbose logging\n');
+            ctx.stdout.write('  -h, --help        Show this help\n\n');
+            ctx.stdout.write('Examples:\n');
+            ctx.stdout.write('  tunnel --port 5173                    Route all traffic to port 5173\n');
+            ctx.stdout.write('  tunnel --server=ws://example.com:3005 Custom tunnel server\n\n');
+            ctx.stdout.write('Without --port, uses path-based routing:\n');
+            ctx.stdout.write('  http://localhost:3005/8080/ → Port 8080 inside lifo\n');
+            ctx.stdout.write('  http://localhost:3005/3000/api/users → Port 3000, path /api/users\n\n');
+            ctx.stdout.write('With --port 5173:\n');
+            ctx.stdout.write('  http://localhost:3005/ → Port 5173, path /\n');
+            ctx.stdout.write('  http://localhost:3005/src/main.ts → Port 5173, path /src/main.ts\n');
+            return 0;
+        }
+        if (!kernel?.portRegistry) {
+            ctx.stderr.write('tunnel: portRegistry not available\n');
+            return 1;
+        }
+        const { server, port: defaultPort, verbose } = options;
+        if (typeof WebSocket === 'undefined') {
+            ctx.stderr.write('tunnel: WebSocket is not available in this runtime\n');
+            return 1;
+        }
+        const WebSocketConstructor = WebSocket;
+        let ws = null;
+        let reconnecting = false;
+        function log(message) {
+            if (verbose) {
+                ctx.stdout.write(`[tunnel] ${message}\n`);
+            }
+        }
+        function logActivePorts() {
+            const ports = Array.from(kernel.portRegistry.keys()).sort((a, b) => a - b);
+            if (ports.length === 0) {
+                ctx.stdout.write('No active servers to tunnel\n');
+                return;
+            }
+            ctx.stdout.write(`\nTunneling ${ports.length} server(s):\n`);
+            for (const port of ports) {
+                if (defaultPort) {
+                    ctx.stdout.write(`  - Port ${port}: http://localhost:3005/\n`);
+                }
+                else {
+                    ctx.stdout.write(`  - Port ${port}: http://localhost:3005/${port}/\n`);
+                }
+            }
+            ctx.stdout.write('\n');
+        }
+        function sendError(requestId, statusCode, message) {
+            if (!ws || ws.readyState !== WebSocketConstructor.OPEN)
+                return;
+            const response = {
+                type: 'response',
+                requestId,
+                statusCode,
+                headers: { 'Content-Type': 'text/plain' },
+                body: Buffer.from(message).toString('base64'),
+            };
+            ws.send(JSON.stringify(response));
+        }
+        function closeWebSocket(socket) {
+            if (socket)
+                socket.close();
+        }
+        async function handleMessage(data) {
+            try {
+                const message = JSON.parse(data.toString());
+                if (message.type === 'request') {
+                    const { requestId, method, url, headers, body } = message;
+                    log(`Received request: ${method} ${url}`);
+                    let port;
+                    let actualPath;
+                    if (defaultPort) {
+                        // Default port mode: all requests go to the default port
+                        port = defaultPort;
+                        actualPath = url || '/';
+                    }
+                    else {
+                        // Path-based routing: /PORT/path
+                        const match = url.match(/^\/(\d+)(\/.*)?$/);
+                        if (!match) {
+                            sendError(requestId, 400, 'Invalid URL format. Use /PORT/path or run tunnel with --port <num>');
+                            return;
+                        }
+                        port = parseInt(match[1], 10);
+                        actualPath = match[2] || '/';
+                    }
+                    // Lookup handler in portRegistry
+                    const handler = kernel.portRegistry.get(port);
+                    if (!handler) {
+                        sendError(requestId, 404, `No server listening on port ${port}`);
+                        return;
+                    }
+                    // Create virtual request/response
+                    const vReq = {
+                        method,
+                        url: actualPath,
+                        headers,
+                        body: Buffer.from(body || '', 'base64').toString(),
+                    };
+                    const vRes = {
+                        statusCode: 200,
+                        headers: {},
+                        body: '',
+                    };
+                    try {
+                        // Call the virtual server handler
+                        handler(vReq, vRes);
+                        if (vRes._donePromise) {
+                            const result = await waitForSignalOrTimeout(vRes._donePromise, ctx.signal, 25_000);
+                            if (result.type === 'aborted') {
+                                return;
+                            }
+                            if (result.type === 'timeout') {
+                                ctx.stderr.write(`[tunnel] TIMEOUT waiting for response: ${method} ${actualPath}\n`);
+                                sendError(requestId, 504, `Gateway timeout: server did not respond for ${actualPath}`);
+                                return;
+                            }
+                        }
+                        // Send response back through tunnel
+                        const response = {
+                            type: 'response',
+                            requestId,
+                            statusCode: vRes.statusCode,
+                            headers: vRes.headers,
+                            body: Buffer.from(vRes.body).toString('base64'),
+                        };
+                        ws?.send(JSON.stringify(response));
+                        log(`Sent response: ${vRes.statusCode}`);
+                    }
+                    catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        ctx.stderr.write(`[tunnel] ERROR for ${method} ${actualPath}: ${errorMessage}\n`);
+                        sendError(requestId, 500, `Internal server error: ${errorMessage}`);
+                    }
+                }
+            }
+            catch (error) {
+                ctx.stderr.write(`tunnel: Error processing message: ${error}\n`);
+            }
+        }
+        function connect() {
+            if (reconnecting || ctx.signal.aborted)
+                return;
+            ctx.stdout.write(`Connecting to tunnel server at ${server}...\n`);
+            ws = new WebSocketConstructor(server);
+            ws.addEventListener('open', () => {
+                reconnecting = false;
+                ctx.stdout.write(`Connected to tunnel server\n`);
+                const httpUrl = server.replace('ws://', 'http://').replace('wss://', 'https://');
+                if (defaultPort) {
+                    ctx.stdout.write(`Tunnel ready — all traffic → port ${defaultPort}\n`);
+                    ctx.stdout.write(`  Open: ${httpUrl}\n`);
+                }
+                else {
+                    ctx.stdout.write(`Tunnel ready at ${httpUrl}\n`);
+                }
+                logActivePorts();
+            });
+            ws.addEventListener('message', (event) => {
+                const data = typeof event.data === 'string'
+                    ? Buffer.from(event.data)
+                    : event.data;
+                handleMessage(data);
+            });
+            ws.addEventListener('close', () => {
+                if (!ctx.signal.aborted) {
+                    ctx.stdout.write('Disconnected from tunnel server\n');
+                    ctx.stdout.write('Reconnecting in 5 seconds...\n');
+                    reconnecting = true;
+                    setTimeout(() => {
+                        reconnecting = false;
+                        connect();
+                    }, 5000);
+                }
+            });
+            ws.addEventListener('error', (event) => {
+                const errorMessage = event instanceof ErrorEvent ? event.message : 'Connection error';
+                ctx.stderr.write(`tunnel: WebSocket error: ${errorMessage}\n`);
+            });
+        }
+        // Initial connection
+        connect();
+        await waitForAbort(ctx.signal);
+        ctx.stdout.write('\nShutting down tunnel...\n');
+        closeWebSocket(ws);
+        return 0;
+    };
+}
+export function createTunnelCommand(kernel) {
+    return createTunnelImpl(kernel);
+}
+// Default command (no kernel)
+const command = createTunnelImpl();
+export default command;

package/dist/substrate/lifo/commands/net/wget.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from '../types.js';
+declare const command: Command;
+export default command;
+//# sourceMappingURL=wget.d.ts.map

package/dist/substrate/lifo/commands/net/wget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wget.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/net/wget.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAG3C,QAAA,MAAM,OAAO,EAAE,OAkFd,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/dist/substrate/lifo/commands/net/wget.js

@@ -0,0 +1,78 @@
+import { resolve } from '../../utils/path.js';
+const command = async (ctx) => {
+    let outputFile;
+    let quiet = false;
+    let url;
+    const args = ctx.args;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case '-O':
+                outputFile = args[++i] ?? '';
+                break;
+            case '-q':
+            case '--quiet':
+                quiet = true;
+                break;
+            default:
+                if (!arg.startsWith('-')) {
+                    url = arg;
+                }
+                break;
+        }
+    }
+    if (!url) {
+        ctx.stderr.write('wget: missing URL\n');
+        ctx.stderr.write('Usage: wget [-O file] [-q] url\n');
+        return 1;
+    }
+    // Ensure URL has protocol
+    if (!url.startsWith('http://') && !url.startsWith('https://')) {
+        url = 'https://' + url;
+    }
+    // Determine output filename
+    if (!outputFile) {
+        try {
+            const urlObj = new URL(url);
+            const pathSegments = urlObj.pathname.split('/').filter(Boolean);
+            outputFile = pathSegments.length > 0 ? pathSegments[pathSegments.length - 1] : 'index.html';
+        }
+        catch {
+            outputFile = 'index.html';
+        }
+    }
+    if (!quiet) {
+        ctx.stderr.write(`--  ${url}\n`);
+        ctx.stderr.write(`Connecting... `);
+    }
+    try {
+        const response = await fetch(url, { signal: ctx.signal });
+        if (!quiet) {
+            ctx.stderr.write(`connected.\n`);
+            ctx.stderr.write(`HTTP request sent, awaiting response... ${response.status} ${response.statusText}\n`);
+        }
+        const body = await response.text();
+        const path = resolve(ctx.cwd, outputFile);
+        ctx.vfs.writeFile(path, body);
+        if (!quiet) {
+            ctx.stderr.write(`Saving to: '${outputFile}'\n`);
+            ctx.stderr.write(`${body.length} bytes saved.\n`);
+        }
+        return response.ok ? 0 : 1;
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        if (!quiet) {
+            ctx.stderr.write(`failed.\n`);
+        }
+        if (msg.includes('Failed to fetch') || msg.includes('NetworkError') || msg.includes('CORS')) {
+            ctx.stderr.write(`wget: unable to connect to ${url}\n`);
+            ctx.stderr.write(`Note: This may be a CORS restriction. The target server must allow cross-origin requests.\n`);
+        }
+        else {
+            ctx.stderr.write(`wget: ${msg}\n`);
+        }
+        return 1;
+    }
+};
+export default command;