Skip to main content
100%

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

✓ Published0🌍 Public
Aackuser
Last edited May 8, 2011
Created on Jul 3, 2017

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.

AI-generated description

Similar vizzes

Loading thumbnail…

node-websocketd

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.

Aalessioalex
66% 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
65% match
Loading thumbnail…

Gist 660bf021ec250dfb10016d384d524bd7

This example shows a real-time chat application where users exchange messages through a Node.js server. The visualization tracks message flow and user activity using a force-directed graph rendered with D3.js’s `d3.forceSimulation` for node positioning and link physics. Each user appears as a node, with edges connecting them to messages they send, while color and size encode online status and message frequency. The code uses Socket.IO for live data updates and D3’s `transition.attrTween` to animate new nodes and links smoothly as events arrive, making the conversation pattern immediately visible.

FFrankieFabuloso
65% 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
62% 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
60% match
Loading thumbnail…

Node read stream

This example streams the contents of a server log file directly to the browser as an HTTP response. It uses Node.js’s `fs.createReadStream` to read the file with UTF-8 encoding, then listens to the `'data'` event to strip newline characters and send each chunk via `res.send`. The code does not perform any visual rendering or charting; instead, it demonstrates a raw data-delivery pattern where log entries are pushed to the client in real time as they are read. No visualization library is involved.

Aalessioalex
60% match
Loading thumbnail…

Gist 75fe6f98cacb874f8d9ebce7248b1b66

This example presents a web-based client-server application that serves static files and handles socket connections. The server is built with Express and Socket.IO, listening on a configurable port, and delegates all routes to a single `index.html` file. It uses the `body-parser` middleware for JSON parsing and the `path` module to resolve file locations. The rendering approach is not specified, but the code clearly establishes the infrastructure for delivering a front-end visualization, with the server acting as the backbone for real-time communication and static asset delivery.

RRonolibert
60% match
Loading thumbnail…

Gist 1075489a3f6f94d13b2ab76cff4c7cea

This example visualizes the asynchronous execution order of Node.js operations by logging their completion times relative to a shared start timestamp. It uses Node’s `https.request` to fetch Google’s homepage, `crypto.pbkdf2` for four CPU-intensive password hashes, and `fs.readFile` to read a local file. The console output reveals how the event loop interleaves I/O callbacks, with the network request finishing before the file read and hash computations, illustrating the non-blocking concurrency model.

Aamazingandyyy
59% match