Skip to main content
100%

Basic XMPP bot example for HipChat using node.js

✓ Published0🌍 Public
Aalessioalex
Last edited Apr 27, 2011
Created on Nov 10, 2012

This example demonstrates a HipChat bot that responds to the `!weather` command by fetching and posting weather information into a group chat. The bot connects via XMPP using the `node-xmpp` library, joins a specified room, and listens for incoming groupchat messages. When a command is detected, it queries the Yahoo YQL API with the `request` library, parses the JSON response, and sends the formatted weather report back to the room. The animation shows the bot’s real-time message handling and reply cycle.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist db569066a21ec6afce10f185d9c1f60b

This example demonstrates a text-based bot connecting to a Mozilla Hubs room, logging presence updates and chat messages, and sending a greeting after a delay. It uses the ReticulumClient and HubState classes from the Hubs Discord Bot libraries to establish a Phoenix channel connection, while HubStats and PresenceRollups track room occupancy over time. The bot reads configuration from dotenv files and logs timestamped events to the console, showing real-time hub activity without any visual rendering.

UUtopiah
63% match
Loading thumbnail…

send commands to a Mozilla Hubs bot via chat

A Mozilla Hubs bot listens to chat messages and triggers actions when a user types a command. The example shows a "save" command that calls `pimvrSaveRemote("HubsTest", "testFromImportToolLibTris")` to save data. The bot runs in the browser and uses the `hubs_bot_command_via_chat.js` script, which loads the Mozilla Hubs library from `https://mozilla-hubs-lib.glitch.me/client.js`. It polls the chat log every 500 milliseconds by selecting `.Linkify` elements, reads the latest message and its author, and avoids repeating commands. The animation renders the bot's behavior in real time within the Hubs client.

UUtopiah
61% match
Loading thumbnail…

swarmchat.html

This animated chat visualization displays a real-time conversation as streaming lines of text. Users type messages into an input box, and each message appears as a line that briefly animates within a 20-em-high container before fading or scrolling. The rendering is driven by a bundled JavaScript library (likely a chat or streaming library) that manages the dynamic DOM updates, creating a simple, live feed effect. The example demonstrates a minimal, functional chat interface with automatic text display and animation.

Aalessioalex
60% match
Loading thumbnail…

Gist 538566

The animation depicts a real-time chat interface with multiple channels and private messaging. It uses jQuery AJAX polling to fetch new messages from a server, maintaining an asynchronous queue to manage requests. The visualization shows chat output with different message types (global notices, private messages, actions, and regular chats) color-coded by category, while tabs for background channels highlight when activity occurs. A maximum of 100 chat lines per channel is enforced, and the display auto-scrolls as new messages arrive.

XXXX
59% 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
59% match
Loading thumbnail…

Gist e788d79614e145d046a33bd7b28a7c55

This example connects a Mozilla Hubs virtual room to a Phoenix channel via the Reticulum client, logging real-time chat messages and presence rollups as they arrive. The code subscribes to channel events with `reticulumCh.channel.on` and tracks room occupancy through `PresenceRollups`, sending a test message with `sendMessage` after five seconds. It uses `HubStats` to record arrival timestamps and `dotenv` for configuration, demonstrating how to build a bot that monitors live activity in a Hubs room.

UUtopiah
59% 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
56% match
Loading thumbnail…

Gist 9e8c4fa996831859a1c099a9906f84e9

This example visualizes the presence of users in a Mozilla Hubs room over time by periodically sampling the room’s member list. It reads the DOM to extract each participant’s nickname and presence status, hashing names for privacy, and stores measurements in `localStorage`. The animation, driven by `setInterval`, appends timestamped snapshots every minute, enabling a temporal view of attendance and activity. The code relies on vanilla JavaScript DOM queries and the `hashCode` function, with no external charting library.

UUtopiah
56% match