SlackSentinel

my logo

Inspiration

Was tired of missing out on important messages hidden in between numerous messages in the channels

What it does

Semantic Threat / Priority Detection Instead of sorting notifications purely by time, Slack would use local machine learning to sort by intent and impact.

Low Priority: "Hey everyone, there are donuts in the breakroom!" or "Check out this meme." (Sent to a low-noise digest).

High Priority: "The production database migrations are failing with a 500 error," or "Hey, I need your eyes on this firewall audit before the client call." (Instantly bumped to your Focus Stream).

Automated "Catch-Me-Up" Timelines If you’ve been away for a few days, instead of reading through 200 backlogged messages in a project channel, you would click a single button to generate a structured timeline of events. It would look something like this:

Issue Identified Monday, 9:00 AM Alex noted that the API container was crashing under heavy payload sizes.

Debugging & Discussion Monday, 11:30 AM The team debated between optimizing the database queries or scaling the cluster. They chose to optimize the indexing first.

Resolution & Pull Request Monday, 2:15 PM Sarah pushed a hotfix resolving the leak. Code is deployed and stable.

True "Deep Work" Shielding When you turn on "Deep Work" mode, Slack wouldn’t just mute notifications—it would actually intercept incoming messages. If a teammate tries to DM you a non-urgent question, Slack would gently tell them: "Hey, they are focusing right now. If this is about the current outage, click 'Interrupt.' Otherwise, we'll hold this message in their queue until 4:00 PM."

How we built it

I designed and engineered SlackEnabler as a robust, full-stack event-driven system:

The Ingress & Routing Layer: Live Slack events (like message.channels or message.im) are captured via Slack's Bolt SDK and piped securely to our local backend utilizing an ngrok public tunnel for immediate webhooks.

The Intelligent Backend Core: Built entirely on a Node.js & Express server. When a message hits the server, it passes through an Intelligent Semantic Filter. We integrated the Gemini 1.5 Flash API to dynamically classify text priority (High vs. Low), backed by a lightning-fast local Regex Intent Classifier fallback.

The Focus Shield Interceptor: This is where the magic happens. The engine cross-references the incoming Slack messages against live MCP telemetry (like active file paths directly from the developer's IDE workspace). If a message matches your active code context, it instantly bypasses the barrier. If it’s casual talk, it’s silently routed to a Digest Queue and tracked inside our local JSON database (data/db.json).

The Presentation Layer: We engineered a sleek frontend dashboard using Vite + React. It continuously polls the database every 5 seconds to render a live Focus Stream panel, a "Catch-Me-Up" timeline generator, an interactive Slack Connect guide, and a complete sandbox environment to simulate mock message incidents.

Challenges we ran into

Building an end-to-end integration during a tight timeline brought some intense hurdles:

The Sandbox Population Trap: During testing in the Slack Enterprise Grid sandbox environment, we opted for a default data template to populate mock channels. However, this hit a hard platform limit of 8 total users, completely locking us out from inviting the external hackathon testing accounts! We had to dive into user management workarounds to clear the mock data and bypass the database restrictions.

Context Synchronization: Forcing an asynchronous Slack webhook to seamlessly map against real-time, fluid IDE telemetry via MCP without creating lag was a massive architecture puzzle. We solved this by creating a unified parallel request model inside the Express router to balance the LLM classification speed against the local telemetry loop.

Environment Configuration Overhaul: Managing token authentications (xoxb- and xapp- keys) across multiple workspace swaps mid-development threatening to break our Socket Mode connections. Instead of repeatedly altering local environment files and breaking a working build, we learned to decouple workspace routing via the Slack Admin console.