import os
import time
from slack_sdk import WebClient
from slack_sdk.errors import SlackApiError

# Initialize Slack client with your bot token
slack_token = os.environ.get("SLACK_BOT_TOKEN")
client = WebClient(token=slack_token)

def update_slack_status(status_text, status_emoji, expiration_minutes=0):
    """
    Update your Slack status with custom text and emoji
    
    Args:
        status_text (str): Status message (e.g., "Deep in code")
        status_emoji (str): Status emoji (e.g., ":keyboard:")
        expiration_minutes (int): Auto-clear after X minutes (0 = manual clear)
    """
    try:
        # Set status expiration if specified
        expiration_ts = 0
        if expiration_minutes > 0:
            expiration_ts = int(time.time()) + (expiration_minutes * 60)
        
        # Update Slack status
        response = client.users_profile_set(
            profile={
                "status_text": status_text,
                "status_emoji": status_emoji,
                "status_expiration": expiration_ts
            }
        )
        print(f"Status updated: {status_emoji} {status_text}")
        return True
        
    except SlackApiError as e:
        print(f"Error updating status: {e.response['error']}")
        return False

# Example usage: Set "Deep in code" status for 90 minutes
update_slack_status(
    status_text="Deep in code",
    status_emoji=":keyboard:",
    expiration_minutes=90
)

# Clear status function
def clear_slack_status():
    """Clear your current Slack status"""
    return update_slack_status("", "", 0)

The Problem: Your Status Is a Lie (And Everyone Knows It)

Let's be honest: your Slack status is about as accurate as a politician's campaign promise. You set it to "In a meeting" when you're actually scrolling through Reddit. You forget to update it when you're deep in flow state, leading to interruptions that shatter your concentration like a dropped coffee mug on concrete. And that "Lunch" status? You've had it on for three hours while you "thought through the architecture."

The modern developer exists in a constant state of status anxiety. Are you signaling enough productivity? Should you appear available for collaboration, or protect your precious focus time? It's like being a Broadway actor whose entire performance is judged by a single emoji next to your name. The absurdity reaches peak levels when you consider we're paid to solve complex technical problems, yet we spend non-trivial brain cycles on this performative theater.

Worst of all, this manual status updating creates cognitive load exactly when you can least afford it. You're debugging a race condition that only happens on Tuesdays during a full moon, and you have to remember to update your status? It's like asking a surgeon to tweet about the surgery while they're holding your spleen.

The Solution: Automation for the Performative Age

I built Slack Status Syncer to solve this ridiculous problem. Instead of manually curating your workplace persona like it's a LinkedIn profile, let the computer do what computers do best: automate repetitive tasks that waste human brainpower.

The tool works by monitoring what you're actually doing and translating that into appropriate Slack statuses. It's like having a personal assistant who understands developer workflows and isn't afraid to tell your coworkers you're "In a flow state" instead of the more honest "Trying to remember how promises work for the 47th time."

Despite the humorous premise, this is actually useful. Studies show it takes an average of 23 minutes to regain deep focus after an interruption. By automatically signaling when you're in flow state, you reduce interruptions. By syncing with your calendar, you prevent people from messaging you during meetings (where you're definitely paying attention and not reading Hacker News). It's productivity theater that actually improves productivity.

How to Use It: Less Thinking, More Doing

Installation is straightforward because you have enough complexity in your life already. Clone the repository, install dependencies, and configure your Slack token (because apparently we need permission to tell people we're busy).

Here's the beautiful part of the main monitoring logic:

def monitor_developer_state():
    """Because developers shouldn't have to think about thinking"""
    
    while True:
        if ide_active_for(15, 'minutes'):
            set_slack_status('In a flow state', ':technologist:')
            
        elif git_commit_detected():
            set_slack_status('Just shipped, recovering', ':ship:')
            
        elif calendar_shows_meeting():
            set_slack_status('In meeting (probably zoning out)', ':meeting:')
            
        elif is_3pm_slump():
            set_slack_status('Pretending to work', ':coffee:')
            
        sleep(60)  # Check every minute, like a concerned parent

Check out the full source code on GitHub for all the glorious details, including error handling for when Slack's API inevitably has an existential crisis.

Key Features: Your New Digital Personal Assistant

• Flow State Detection: Automatically sets Slack status to 'In a flow state' when your IDE has been active for >15 minutes. Because nothing says "don't interrupt me" like admitting you're actually productive.
• Commit Celebration: Detects git commits and changes status to 'Just shipped, recovering' with appropriate emoji. The recovery period is crucial—shipping code is emotionally draining.
• Calendar Syncing: Syncs with your calendar to show 'In meeting (probably zoning out)'. Honest enough to be believable, vague enough to avoid HR complaints.
• 3pm Honesty: Option to manually trigger 'Pretending to work' status for those post-lunch slumps. Sometimes truth is the best policy, especially when you're watching cat videos.
• Custom Status Library: Pre-loaded with developer-appropriate statuses like 'Debugging my life choices', 'In standup (mentally elsewhere)', and 'Code compiling (aka coffee break)'.

Conclusion: Reclaim Your Mental Bandwidth

Slack Status Syncer isn't just about automating status updates—it's about reclaiming the mental bandwidth we waste on performative productivity. Instead of thinking about how to signal you're working, you can actually work. Instead of pretending to be available, you can protect your focus time. It's a small tool that solves a ridiculous but real problem in modern development.

Try it out: https://github.com/BoopyCode/slack-status-syncer

Because in a world where we automate CI/CD pipelines, container orchestration, and database migrations, it's about time we automated the most tedious performance of all: pretending we're not pretending to work.