Skip to main content
100%

node-websocketd

✓ Published0🌍 Public
Aalessioalex
Last edited Dec 9, 2013
Created on Dec 9, 2013

This example demonstrates a lightweight Node.js port of the websocketd tool, which exposes a command-line script over a WebSocket connection. It shows how a spawned child process can receive input from and send output to a connected browser client in real time. The implementation uses the `ws` Server to handle WebSocket connections, `websocket-stream` to create a duplex stream over the socket, and `child_process.spawn` to execute the user-supplied command. Standard input and output are piped between the stream and the spawned process, with the process being killed when the stream ends.

AI-generated description

node-websocketd

A lightweight node port of websocketd, originally written in go.

Usage

node-websocketd --port=8080 ./count.sh

Similar vizzes

Loading thumbnail…

Node.js + Socket.io + Bash. A collaborative terminal for your browser.

This example demonstrates a collaborative terminal in the browser, where multiple users share a live bash session and see each other’s commands and output in real time. It shows a simple web page that displays the shell’s stdout and stderr as a scrolling log, while a text input lets any connected client send commands to the server. The server uses Node.js’s `child_process.spawn` to launch bash, and Socket.io’s `listen` and `broadcast` methods to relay data between the shell and all clients. The client-side `term.html` uses jQuery for DOM updates and Socket.io’s `io.Socket` for message handling, rendering each line as a `<p>` element.

Aackuser
66% match
Loading thumbnail…

Gist 48d689f1ba856686fff5

This example demonstrates a simple WebSocket-based message exchange between a server and a browser client. The server sends a `server_ping` event with a `Hello bob` payload, and the client’s JavaScript listens for that event, logs the incoming message to the console, and also handles disconnections. The visualization itself is minimal, relying on the browser console for output rather than graphical rendering. The code uses the raw WebSocket API through a channel object (likely from a library like Socket.IO or similar) and standard `console.log` for feedback.

Aandybak
62% match
Loading thumbnail…

Using sendfile(2) with NodeJS

This example demonstrates using the `sendfile(2)` system call in NodeJS to stream file contents over a TCP connection, bypassing userspace buffering for efficiency. It creates a net server that opens a file with `process.binding('fs').open` and sends data in chunks via `sendfile`, tracking the file offset across invocations. The code handles `EAGAIN` errors by listening for the `'drain'` event and manually starting the socket’s `_writeWatcher` to resume transmission, ultimately ending the connection when the file is fully sent. The file path and port are supplied as command-line arguments.

Aalessioalex
61% match
Loading thumbnail…

Gist 1070395

This example demonstrates a real-time messaging dashboard where a Node.js server relays messages to a browser client over the Faye Bayeux protocol. It shows how server-side JavaScript publishes messages to a subscribed client, which logs incoming text to the console. The code sets up an HTTP server with `http.createServer`, serves static HTML files from the filesystem, and attaches Faye’s `NodeAdapter` to handle WebSocket connections at `/faye`. A `Faye.Client` subscribes to the `/messages` channel, receiving and printing each message’s `text` property. The rendering relies on terminal output rather than visual charts.

Aalessioalex
60% match
Loading thumbnail…

zombie processes nodejs

This example demonstrates how to create a detached child process in Node.js that continues running independently of its parent. The code uses the `child_process.spawn` API to launch a new Node.js process executing `zombie.js`, with all standard streams (`stdin`, `stdout`, `stderr`) set to `'ignore'` and the `detached: true` option enabled. By calling `child.unref()`, the parent process removes the child from its event loop, allowing the parent to exit while the child persists as a zombie process. The example references Stack Overflow guidance and Node.js documentation on detached processes, illustrating a pattern for background tasks.

Aalessioalex
59% match
Loading thumbnail…

Node command line read from input (hope I get this working)

This example demonstrates a minimal interactive command-line interface in Node.js. It reads user input from standard input, echoes the entered text with a prompt prefix, and terminates when the user types “exit”. The code uses `process.openStdin()` to access the input stream, sets its encoding to UTF-8, and registers a data event handler via `stdin.on('data', ...)` to process each line of input. No external libraries are required; it relies solely on Node.js built-in process and stream APIs.

Aalessioalex
59% match
Loading thumbnail…

Gist 4698533

This example implements a SOCKS5 proxy server in Node.js, demonstrating the TCP connection flow between a client, proxy, and destination. It shows the handshake, authentication (using USERPASS), and request forwarding stages. The code uses the `net` module’s `createServer` and `createConnection` APIs to handle incoming sockets and outbound TCP links, with buffer manipulation for parsing SOCKS5 headers, address types (IPv4, domain, IPv6), and ports. All connections are accepted, authorized, and relayed, though the `authorize` function always returns true.

Aalessioalex
57% match
Loading thumbnail…

Winston..

The example demonstrates a Node.js server setup that uses Winston for logging operations. It initializes a Winston logger with both console and file transports, writing log entries to `log/server.log` while also capturing exceptions to a separate file. The code shows how to create a logger instance via `winston.Logger`, configure transports like `winston.transports.Console` and `winston.transports.File`, and record messages using `logger.log('info', ...)` and `logger.info(...)`. The visible data source is the hardcoded log strings, with the rendering approach being text output to console and file.

Aalessioalex
57% match