@nimbus-sh/core 0.1.0

package/src/substrate/lifo/commands/net/tunnel.ts

@@ -0,0 +1,272 @@
+import type { Command } from '../types.js';
+import type { Kernel } from '../../kernel/index.js';
+import type { VirtualResponseWithDone } from '../../node-compat/http.js';
+import { Buffer } from '../../node-compat/buffer.js';
+import { waitForAbort, waitForSignalOrTimeout } from '../signal.js';
+
+interface TunnelOptions {
+	server: string;
+	port: number | null;
+	verbose: boolean;
+}
+
+function parseArgs(args: string[]): TunnelOptions | { help: true } {
+	let server = 'ws://localhost:3005';
+	let port: number | null = 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?: Kernel): Command {
+	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 as TunnelOptions;
+
+		if (typeof WebSocket === 'undefined') {
+			ctx.stderr.write('tunnel: WebSocket is not available in this runtime\n');
+			return 1;
+		}
+		const WebSocketConstructor = WebSocket;
+
+		let ws: WebSocket | null = null;
+		let reconnecting = false;
+
+		function log(message: string) {
+			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: string, statusCode: number, message: string) {
+			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: WebSocket | null) {
+			if (socket) socket.close();
+		}
+
+		async function handleMessage(data: Buffer) {
+			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: number;
+					let actualPath: string;
+
+					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: VirtualResponseWithDone = {
+						statusCode: 200,
+						headers: {} as Record<string, string>,
+						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: Kernel): Command {
+	return createTunnelImpl(kernel);
+}
+
+// Default command (no kernel)
+const command: Command = createTunnelImpl();
+
+export default command;

package/src/substrate/lifo/commands/net/wget.ts

@@ -0,0 +1,88 @@
+import type { Command } from '../types.js';
+import { resolve } from '../../utils/path.js';
+
+const command: Command = async (ctx) => {
+  let outputFile: string | undefined;
+  let quiet = false;
+  let url: string | undefined;
+
+  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;

package/src/substrate/lifo/commands/registry.ts

@@ -0,0 +1,141 @@
+import type { Command } from './types.js';
+
+export class CommandRegistry {
+  private commands = new Map<string, Command>();
+  private lazy = new Map<string, () => Promise<{ default: Command }>>();
+
+  register(name: string, command: Command): void {
+    this.commands.set(name, command);
+  }
+
+  registerLazy(name: string, loader: () => Promise<{ default: Command }>): void {
+    this.lazy.set(name, loader);
+  }
+
+  unregister(name: string): void {
+    this.commands.delete(name);
+    this.lazy.delete(name);
+  }
+
+  async resolve(name: string): Promise<Command | undefined> {
+    const cmd = this.commands.get(name);
+    if (cmd) return cmd;
+
+    const loader = this.lazy.get(name);
+    if (loader) {
+      const mod = await loader();
+      this.commands.set(name, mod.default);
+      this.lazy.delete(name);
+      return mod.default;
+    }
+
+    return undefined;
+  }
+
+  has(name: string): boolean {
+    return this.commands.has(name) || this.lazy.has(name);
+  }
+
+  list(): string[] {
+    const names = new Set([...this.commands.keys(), ...this.lazy.keys()]);
+    return [...names].sort();
+  }
+}
+
+export function createDefaultRegistry(): CommandRegistry {
+  const registry = new CommandRegistry();
+
+  // File system
+  registry.registerLazy('ls', () => import('./fs/ls.js'));
+  registry.registerLazy('cat', () => import('./fs/cat.js'));
+  registry.registerLazy('mkdir', () => import('./fs/mkdir.js'));
+  registry.registerLazy('rm', () => import('./fs/rm.js'));
+  registry.registerLazy('cp', () => import('./fs/cp.js'));
+  registry.registerLazy('mv', () => import('./fs/mv.js'));
+  registry.registerLazy('touch', () => import('./fs/touch.js'));
+  registry.registerLazy('find', () => import('./fs/find.js'));
+  registry.registerLazy('tree', () => import('./fs/tree.js'));
+  registry.registerLazy('stat', () => import('./fs/stat.js'));
+  registry.registerLazy('ln', () => import('./fs/ln.js'));
+  registry.registerLazy('du', () => import('./fs/du.js'));
+  registry.registerLazy('df', () => import('./fs/df.js'));
+  registry.registerLazy('chmod', () => import('./fs/chmod.js'));
+  registry.registerLazy('file', () => import('./fs/file.js'));
+
+  // Text processing
+  registry.registerLazy('grep', () => import('./text/grep.js'));
+  registry.registerLazy('head', () => import('./text/head.js'));
+  registry.registerLazy('tail', () => import('./text/tail.js'));
+  registry.registerLazy('wc', () => import('./text/wc.js'));
+  registry.registerLazy('sort', () => import('./text/sort.js'));
+  registry.registerLazy('uniq', () => import('./text/uniq.js'));
+  registry.registerLazy('cut', () => import('./text/cut.js'));
+  registry.registerLazy('tr', () => import('./text/tr.js'));
+  registry.registerLazy('sed', () => import('./text/sed.js'));
+  registry.registerLazy('awk', () => import('./text/awk.js'));
+
+  // I/O utilities
+  registry.registerLazy('tee', () => import('./io/tee.js'));
+  registry.registerLazy('xargs', () => import('./io/xargs.js'));
+  registry.registerLazy('yes', () => import('./io/yes.js'));
+  registry.registerLazy('printf', () => import('./io/printf.js'));
+  registry.registerLazy('dd', () => import('./io/dd.js'));
+
+  // System
+  registry.registerLazy('env', () => import('./system/env.js'));
+  registry.registerLazy('uname', () => import('./system/uname.js'));
+  registry.registerLazy('date', () => import('./system/date.js'));
+  registry.registerLazy('sleep', () => import('./system/sleep.js'));
+  registry.registerLazy('uptime', () => import('./system/uptime.js'));
+  registry.registerLazy('whoami', () => import('./system/whoami.js'));
+  registry.registerLazy('hostname', () => import('./system/hostname.js'));
+  registry.registerLazy('free', () => import('./system/free.js'));
+  registry.registerLazy('which', () => import('./system/which.js'));
+  registry.registerLazy('stty', () => import('./system/stty.js'));
+
+  // Network
+  registry.registerLazy('curl', () => import('./net/curl.js'));
+  registry.registerLazy('wget', () => import('./net/wget.js'));
+  registry.registerLazy('ping', () => import('./net/ping.js'));
+  registry.registerLazy('dig', () => import('./net/dig.js'));
+
+  // Archive
+  registry.registerLazy('tar', () => import('./archive/tar.js'));
+  registry.registerLazy('gzip', () => import('./archive/gzip.js'));
+  registry.registerLazy('gunzip', () => import('./archive/gunzip.js'));
+  registry.registerLazy('zip', () => import('./archive/zip.js'));
+  registry.registerLazy('unzip', () => import('./archive/unzip.js'));
+
+  // System (continued)
+  registry.registerLazy('node', () => import('./system/node.js'));
+
+  // Filesystem (continued)
+  registry.registerLazy('rmdir', () => import('./fs/rmdir.js'));
+  registry.registerLazy('realpath', () => import('./fs/realpath.js'));
+  registry.registerLazy('basename', () => import('./fs/basename.js'));
+  registry.registerLazy('dirname', () => import('./fs/dirname.js'));
+  registry.registerLazy('mktemp', () => import('./fs/mktemp.js'));
+  registry.registerLazy('chown', () => import('./fs/chown.js'));
+
+  // Text (continued)
+  registry.registerLazy('diff', () => import('./text/diff.js'));
+  registry.registerLazy('nl', () => import('./text/nl.js'));
+  registry.registerLazy('rev', () => import('./text/rev.js'));
+  registry.registerLazy('nano', () => import('./text/nano.js'));
+  registry.registerLazy('less', () => import('./text/less.js'));
+  registry.registerLazy('tac', () => import('./text/tac.js'));
+  registry.registerLazy('seq', () => import('./text/seq.js'));
+  registry.registerLazy('base64', () => import('./text/base64.js'));
+  registry.registerLazy('strings', () => import('./text/strings.js'));
+
+  // System (continued)
+  registry.registerLazy('cal', () => import('./system/cal.js'));
+  registry.registerLazy('bc', () => import('./system/bc.js'));
+  registry.registerLazy('man', () => import('./system/man.js'));
+  registry.registerLazy('sha256sum', () => import('./system/sha256sum.js'));
+  registry.registerLazy('sl', () => import('./system/sl.js'));
+  registry.registerLazy('fastfetch', () => import('./system/fastfetch.js'));
+  registry.registerLazy('neofetch', () => import('./system/fastfetch.js'));
+
+  return registry;
+}

package/src/substrate/lifo/commands/signal.ts

@@ -0,0 +1,65 @@
+export type WaitResult<T> =
+  | { type: 'done'; value: T }
+  | { type: 'aborted' }
+  | { type: 'timeout' };
+
+export function waitForSignalOrTimeout<T>(
+  promise: Promise<T>,
+  signal: AbortSignal,
+  timeoutMs: number,
+): Promise<WaitResult<T>> {
+  if (signal.aborted) {
+    return Promise.resolve({ type: 'aborted' });
+  }
+
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let timer: ReturnType<typeof setTimeout>;
+    let onAbort: () => void;
+    const cleanup = () => {
+      clearTimeout(timer);
+      signal.removeEventListener('abort', onAbort);
+    };
+    const finish = (result: WaitResult<T>) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(result);
+    };
+    onAbort = () => finish({ type: 'aborted' });
+
+    timer = setTimeout(() => finish({ type: 'timeout' }), timeoutMs);
+    signal.addEventListener('abort', onAbort, { once: true });
+    promise.then(
+      (value) => finish({ type: 'done', value }),
+      (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(error);
+      },
+    );
+  });
+}
+
+export function waitForAbort(signal: AbortSignal): Promise<void> {
+  if (signal.aborted) {
+    return Promise.resolve();
+  }
+
+  return new Promise((resolve) => {
+    const onAbort = () => {
+      signal.removeEventListener('abort', onAbort);
+      resolve();
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+  });
+}
+
+export async function waitForAbortOrTimeout(
+  signal: AbortSignal,
+  timeoutMs: number,
+): Promise<'aborted' | 'timeout'> {
+  const result = await waitForSignalOrTimeout(new Promise<never>(() => {}), signal, timeoutMs);
+  return result.type === 'aborted' ? 'aborted' : 'timeout';
+}