DEV Community: Jack McGuire

Batch publishing Twitch chatroom messages - with AWS Lambda Durable Multi-Step Executions

Jack McGuire — Thu, 11 Dec 2025 15:11:21 +0000

Hi all!

AWS have announced yet another AWS Lambda feature release.

In this post I will be covering a use-case for a Lambda that utilises durable multi-step executions. I will be covering overall thoughts, gotchas and summary.

What are Durable AWS Lambda Functions?

AWS Lambda announces durable functions, enabling developers to build reliable multi-step applications and AI workflows within the Lambda developer experience.

Durable functions automatically checkpoint progress, suspend execution for up to one year during long-running tasks, and recover from failures - all without requiring you to manage additional infrastructure or write custom state management and error handling code.

Use-Case

As you may or may not know, I run a Twitch Extension 'Stat-Milestones'. In short the Twitch Extension renders a widget on streamer's profiles, this widget displays a multitude of social goals information to viewers [Followers, Subscribers, Hypetrains, Charities, etc]

Twitch Extensions have the ability [user-permitted] to publish messages to the public chatroom of a Twitch streamer via the Twitch API.

Generally as a viewer you will see messages from Twitch bots/extensions that provide information like reminders to follower the streamer you're viewing or links to external profiles, etc.

For a long while, I have been intending to setup a pipeline to publish daily messages to Twitch streamers chatrooms. With the intention to remind streamers to update their Twitch goals and Stat-Milestones metrics!
Other communication methods are available, but their chatroom will definitely catch their attention!

With the announcement of AWS Lambda Durable Multi-Step Executions, I figure this is the perfect opportunity to have a play with the new feature and hopefully provide some insightful information if you're thinking about adopting Durable executions yourself!

Why not just use Step-Functions?

To note, I use AWS SAM [YAML] to deploy infrastructure for my Twitch Extension.

Personally setting up infrastructure for a step-function takes the above average complexity for IaC, see Create a Step Functions state machine using AWS SAM.

With Durable AWS Lambdas, the need to develop state definitions is now instead done all in-code and the abundant step execution features are found directly within a new tab on the Lambda dashboard.

The Amazon States Language is a JSON-based, structured language used to define your state machine, a collection of states, that can do work (Task states), determine which states to transition to next (Choice states), stop an execution with an error (Fail states), and so on.

Durable Lambda Implementation

In this section I will detail how I created an application to publishing daily reminder messages to Twitch chatrooms.

In order to publish daily reminders to Twitch streamer chatrooms, I thought about how I require to break this down into notable Durable execution steps.

User Discovery
Batch Publishing of reminder messages
Result Aggregatation

Discovery

The goal of this step is to discover users from a Mongo collection who have granted the permissions to allow my Twitch Extension to publish to their chatroom AND still have a valid auth token.

Batch publishing of messages

In this step, the intention is to construct reminder message(s) and publish them to users found in the discovery phase.

I already have an existing pipeline [sqs -> lambda] in the us-east-1 region that processes messages from a SQS queue and constructs API requests to Twitch to publish the messages to the chatrooms directly.

Simply this execution step just requires to construct SQS Messages and publish them to an external Queue (living in us-east-1 not us-east-2!)

Aggregating Results

This execution step is to aggregate the final results of the prior steps... user discovery, message publishing metrics, etc.

Implementation

With the help of AI tools, I set out to create a Python run-time Durable AWS Lambda function that implements the discovery, batch and result aggregations into seperate steps.

Utilising Steps and Map context processing, we can seperate out the discovery and results into singular steps.

For the Batch Publishing of messages, we can do something clever and utilise the context map. This example demonstrates how durable functions combine map() operations with chunking and rate limiting to handle large-scale data processing.

Code

My example Durable lambda code can be found here

The file has to be compiled into a zip with the external packages

requirements.txt
pymongo>=4.10.1
boto3>=1.35.0
aws-durable-execution-sdk-python>=0.1.0

Dashboard Breakdown

The new Durable execution tab found on the Lambda dashboard brings, somewhat familiar widgets to step-functions.

The ability to inspect the inputs/outputs of step executions is a big win for future applications built with Lambda, reduces the need to deep-dive on logs to inspect payloads and results between steps.

Example Pictures

Here find examples of the inspected durable execution and nested step execution details.

I have not supplied user discovery step due to GDPR reasons, however please find screenshots of durable step executions

Outcome

The end goal of course is to post reminders

Gotchas

limited region availability - as of writing
limited run-time support [Node, Python] - as of writing

Useful links

https://stat-milestones.dev
Twitch Extension About Page

Making an MCP server for the twitch-cli to aid developer experience

Jack McGuire — Mon, 12 May 2025 12:10:50 +0000

Simulate Twitch Event-Sub Events via Cursor with an MCP Server for the `twitch-cli`.

When building Twitch integrations—like chat bots, overlays, or EventSub-powered features—testing can be painful without real user actions triggering events. That's where the Twitch CLI and fastmcp come in.

In this post, I'll show how I set up a local MCP server using fastmcp, and how I use it to trigger events like a Twitch follow using twitch-cli.

What Is an MCP Server?

In the context of tools like Cursor (and possibly other AI IDEs), an MCP server lets you define custom “tools” in code—these tools can then be called by the AI as part of its workflow.

It’s a simple protocol: your server runs locally and exposes functions with structured inputs/outputs over Server-Sent Events (SSE). When the AI tool calls one of your functions, it hits your server and gets the result.

Using `fastmcp` to Build a Local MCP Server for Cursor AI + Twitch CLI Integration

If you're using an AI coding tool like Cursor, you might've come across their support for MCP (Model Context Protocol) servers—a way to define your own tools that the AI can invoke directly while coding.

In this post, I’ll show how I’m using fastmcp to set up a local MCP server, which I’ve wired up to Twitch CLI. With this, I can write prompts in Cursor like:

simulate a twitch follow eventsub event, for user 1234567890

Project Structure

I have the following in my repo:

`./cursor/mcp.json`

This config tells cursor to use my local MCP server:

{
  "mcpServers": {
    "twitchCli": {
      "url": "http://127.0.0.1:8000/sse/",
      "disabled": false,
      "autoApprove": []
    }
  }
}

MCP Server code

server.py

from fastmcp import FastMCP, Context
from typing import Dict, Any
import os
import subprocess
import shlex

mcp = FastMCP("twitch-cli")

@mcp.tool("trigger_twitch_follow_event")
async def trigger_twitch_follow_event(user_id: str, ctx: Context) -> Dict[str, Any]:
    """
    Trigger a Twitch follow event for a specific user ID.

    Args:
        user_id (str): The Twitch user ID to trigger the follow event for

    Returns:
        Dict[str, Any]: Command output or error message
    """
    domain = os.getenv("DOMAIN")
    password = os.getenv("TWITCH_EVENTSUB_SECRET")
    command = f'twitch event trigger follow -t {user_id} -s {password} -F "https://{domain}/twitch-eventsub"'

    try:
        # Split the command into a list of arguments
        args = shlex.split(command)

        # Execute the command and capture output
        result = subprocess.run(
            args,
            capture_output=True,
            text=True,
            check=True
        )

        return {
            "success": True,
            "stdout": result.stdout,
            "stderr": result.stderr,
            "return_code": result.returncode
        }
    except subprocess.CalledProcessError as e:
        return {
            "success": False,
            "error": str(e),
            "stdout": e.stdout,
            "stderr": e.stderr,
            "return_code": e.returncode
        }

if __name__ == "__main__":
    mcp.run(transport="sse")`

Running locally

export DOMAIN=example.com
export TWITCH_EVENTSUB_SECRET=xxx
python server.py
ask your ide AI code agent “Trigger a Twitch follow event for user 12345”

Images

Final Thoughts

This workflow has been game-changing for building Twitch integrations. I can now prototype and test my EventSub logic without writing manual cli commands, rather just describe the desired event and targeted Twitch user I want in the Cursor AI Chat agent, and it triggers the action via my local tool.

If you're building tools that benefit from programmatic APIs, local scripts, or devops integrations, fastmcp + Cursor’s tool-calling support is an incredibly powerful setup.**

Wheel Of Fortune

Jack McGuire — Sun, 21 Aug 2022 18:07:00 +0000

Overview of My Submission

A Wheel Of Fortune project that utilises REDIS in order to maintain wheel segment prize allocation and distribution.

This project comes with a GRPC Server, Client and Admin client built in GO to maintain wheels.

A VUEJS website built with GRPC, ENVOY was created to spin the virtual Wheel Of Fortune!

Submission Category:

Wacky Wildcards

Screenshots!

Language Used

GO, Javascript, LUA

Link to Code

jackmcguire1 / wheeloffortune

grpc - wheel of fortune svc

REDIS - Wheel Of Fortune

A simualted Wheel Of Fortune backed by Redis exposed by a GRCP Server & Client.

How it works

This project simulates a Wheel Of Fortune by making use of Redis to maintain the segments of a wheel i.e. prize allocation and distribution

The server makes use of Redis LUA scripts to synchronously execute user spins and exposes an API via GRPC to maintain and spin and wheels of fortune!

How the data is stored:

Segments and Operational Flags of a wheel of fortune are stored in Redis Keys.

Wheel Of Fortune Creation

When a wheel is CREATED the following keys are generated:

wheel of fortune segment(s)

For each defined segment within a wheel of fortune with an allocated prize a REDIS key like 'wheel:{wheelname}:segment:{index}', data is stored like INCRBY {KEY} {VALUE} in a TX

wheel of fortune Enabled Status

To set the enable status…

View on GitHub

Additional Resources / Info

REDIS for wheel of fortune management
GO to expose a GRPC API
ENVOY is used to provide a HTTP TO GRPC proxy
VUEJS for front-end webapp

Jack McGuire https://github.com/jackmcguire1

Check out Redis OM, client libraries for working with Redis as a multi-model database.
Use RedisInsight to visualize your data in Redis.
Sign up for a free Redis database.