jasonkeene / anubot Goto Github PK

Relevant links:

https://api.betterttv.net/2/emotes
https://api.betterttv.net/2/channels/thaithyme
https://cdn.betterttv.net/emote/5745f699a50053bf42b66480/1x

This can just be state that is stored in the client.

This includes both disconnects to Twitch/Discord but also disconnects of the electron app to the api.

bot.Bot no longer manages connection state so there is a lot of code to rip out. It is now a long running process that runs concurrently alongside other instances. It receives messages from dispatch and writes messages out via stream.Manager. It needs to be able to be reconfigured on the fly to enable/disable features. Perhaps there needs to be some sort of bot.Manager that serves as bookkeeping so that the api can communicate directly with the bot.

• Rip out connection related code.
• Wire up sub socket.
• Wire up message sending.
• Add basic feature to demo bot.
• Think through configuration.
• Implement bot.Manager.

• API should allow client to update stream status and game.
• UI work to emit event.

Consider supporting multiple currencies.

I initially delegated topic resolution to the store. This can be statically set when creating a connection in the stream.Manager.

• remove topic resolution from store
• get echo feature working with twitch
• figure out how topic resolution will work for discord
• get echo feature working with discord

dispatch needs to:

• Accept messages
• Do a somewhat decent job at deduping messages within a certain time frame
• Allow subscribers to stream messages

Things to consider:

• How will bots subscribe for their information?
• How to prevent messages going to the wrong bot?

Remaining TODOs:

• Dedupe messages
• Figure out topic to publish messages by

We'll likely want to leverage the permission systems of Twitch and Discord.

After reading over their readme this would be a good fit for persisting data while in development.

WHISPER is not a standard command, it is something we request the IRCv3 capability for. We might need to patch fluffle/goirc to support dispatching these commands. Here is the relevant post:

https://discuss.dev.twitch.tv/t/whispers-on-irc/2459

A few of the store methods do not return errors. This was because with dummy implementation everything was done in memory. Now that there are actual backends errors need to be returned.

This can be done right before public release.

I got this in my logging one stream, should probably look into it:

@badges=turbo/1;color=#B20AC2;display-name=Aeowynne;emotes=;mod=0;room-id=123750783;subscriber=0;turbo=1;user-id=36125726;user-type= :[email protected] PRIVMSG #postcrypt :ACTION has no idea wtf is going on. In purple

Allow users to search their chat history.

I've started some work on this locally.

Saw this in one of our builds:

https://travis-ci.org/jasonkeene/anubot/builds/168160513#L915

Messages need to be stored. Just need something that pulls from dispatch and writes to store. There needs to be a query interface on the store to search through messages for a given user. Eventually this will be elastic search but for now just implement something naive.

• Implement boltdb method for storing messages.
• Implement boltdb method for querying.
• Stub dummy method for storing messages.
• Stub dummy method for querying.
• Add dispatch reader that writes into store.
• Order messages by timestamp
• Limit recent messages to 500

• Submit PR against a8m/expect for To.Be.True and To.Be.False

This will include the logo and wordmark.

Some music services to consider integration with:

• SoundCloud
• Spotify
• YouTube
• Pandora

Just need to swap out the badge code with something that pulls from here: https://github.com/justintv/Twitch-API/blob/master/v3_resources/chat.md#get-chatchannelbadges

This will take considerable thought. I was thinking about implementing some sort of filtering system so that you can have a single unified chat and simply filter in/out what you want. Discuss this more with thaithyme.

This will include:

• Logo
• Wordmark
• Basic color pallet

Twitch scopes:

• ? user_read: Read access to non-public user information, such as email address.
• Y user_blocks_edit: Ability to ignore or unignore on behalf of a user.
• Y user_blocks_read: Read access to a user's list of ignored users.
• ? user_follows_edit: Access to manage a user's followed channels.
• ? channel_read: Read access to non-public channel information, including email address and stream key.
• Y channel_editor: Write access to channel metadata (game, status, etc).
• Y channel_commercial: Access to trigger commercials on channel.
• ? channel_stream: Ability to reset a channel's stream key.
• Y channel_subscriptions: Read access to all subscribers to your channel.
• ? user_subscriptions: Read access to subscriptions of a user.
• ? channel_check_subscription: Read access to check if a user is subscribed to your channel.
• Y chat_login: Ability to log into chat and send messages.
• Y channel_feed_read: Ability to view to a channel feed.
• Y channel_feed_edit: Ability to add posts and reactions to a channel feed.

• Get pipeline created and committed under /ci.
• Move Dockerfiles under /ci
• Job for running unit tests
• Stub out job for building and pushing as a single github release:
  • Electron app:
    • Windows
    • MacOS
    • Linux
  • Binaries for linux amd_64.

Basic ideas:

• use oauth2 to tie discord user with our user
• try to integrate with existing oauth2 flow from twitch
• once discord user access is granted send the user to url to add anubot to their guild

The output when assertions fail with testify is not detailed enough. Move tests to using a8m/expect.

The client currently stores the username/password in localStorage. This will not work for features like second factor auth. This is required for #36.

This lookup should probably be done outside the store layer. Store should have no concern about Twitch's API.

• Get AWS/github credentials needed for pipeline
• Deploy concourse via terraform to DO
• Set pipeline
• Ensure entire pipeline works (if it doesn't make modifications and destroy/set pipeline again)

The api package needs to subscribe to messages from dispatch and send them down the connection when it is properly authenticated.

• Rework authentication flow.
• API should allow client to subscribe to messages for that user.
• Rework marshaling of message events so that it works for both discord and twitch.
• API should allow client to send messages for both streamer and bot.

User should be able to change their stream status and what game they are playing. The UI for selecting game needs to cache popular games but allow for manually typing in their game.

• Add caching method to twitch.API
• Add handler to websocket API
• Have UI query for games
• Create search box for games
• Key down/key up should select game

This is dependent on #35.

Discuss this with thaithyme to see if it would be useful.

Lots of work to be done here. I'll need to flesh this issue out when I start on it.

When I pulled out the IRC connection logic from the bot I forgot to request capabilities from the server.

https://travis-ci.org/jasonkeene/anubot/builds/165425450