
## The What

I want to make a chatbot for fun and profit. But also to do reminders, tell me the weather, remind
me of calendar items... personal-assistent-type stuff.

[Discord] demands that its chatbots maintain a WebSocket gateway with an always-on connection back
to their servers to receive realtime events (reactions, mentions, and the like). No serverless
platform I have available to me provides for such usage. Every serverless provider I can find
expects a shorter-lived request/response model well suited for HTTP traffic or API calls. That means
I need to run a server for the WebSocket gateway.

Because it's the future I want the main "body" of the chatbot to run in a [Docker] container. Any
other piece of functionality for the chatbot can run on a serverless platform. Thus, I really only
need to host a single Docker container in a production environment.

Finding a way to easily and reliably run a single Docker container in a production environment is a
funny kind of problem to my programmer brain used to dozens of microservices that all run basically
independently.

* Kubernetes is probably overkill. It's a single service with no available HTTP endpoint that should
  restart if it crashes. Most k8s solutions require at least two nodes, which is immediately too
  expensive given the resources I actually need.
* Run it in my home network. I could probably put the gateway on a cheapo computer somewhere in my
  house and script updates that way. So far I've been able to *not* have my network accept incoming
  requests; if I use something like GitHub Actions as CI that would have to change. I could also
  poll GitHub to see if the bot's repo changed, but that's yucko city (ask me about being #1 at
  GitHub sometime).
* Run a tiny, single production server. This seems the likeliest route. Keeps running if my home
  network goes down, reachable from wherever, easy to manage ops-wise.

Sounds like I'm running a $5/month server somewhere and pushing new Docker images to it when the
main gateway repo builds successfully.

## The How

Probably build the Docker container via this: <https://github.com/docker/build-push-action> and push
to Docker Hub (in a GitHub action, natch).

But how to get it to the server?

Current solution is a messy combo detailed here: <https://github.com/derp-bot/bot/commit/033fd0b596fcb50c3265272507a82196f625b665>

* First, build the thing: <https://github.com/derp-bot/bot/blob/033fd0b596fcb50c3265272507a82196f625b665/.github/workflows/deploy-the-bot.yml#L13>
* Then, deploy the thing: <https://github.com/derp-bot/bot/blob/033fd0b596fcb50c3265272507a82196f625b665/.github/workflows/deploy-the-bot.yml#L38>
  * That involves fun things like finding the might-have-changed-IP of the server: <https://github.com/derp-bot/bot/blob/033fd0b596fcb50c3265272507a82196f625b665/.github/workflows/deploy-the-bot.yml#L53>
  * ...and then writing an SSH config: <https://github.com/derp-bot/bot/blob/033fd0b596fcb50c3265272507a82196f625b665/.github/workflows/deploy-the-bot.yml#L61>
  * ...and *then* call my deploy script: <https://github.com/derp-bot/bot/blob/033fd0b596fcb50c3265272507a82196f625b665/.github/workflows/deploy-the-bot.yml#L76>
  * ...which is here: <https://github.com/derp-bot/bot/blob/033fd0b596fcb50c3265272507a82196f625b665/bin/deploy.sh>
    * It mostly SSH's into my box with some env: <https://github.com/derp-bot/bot/blob/033fd0b596fcb50c3265272507a82196f625b665/bin/deploy.sh#L21>
  * The script running on my prod box is here: <https://github.com/derp-bot/bot/blob/033fd0b596fcb50c3265272507a82196f625b665/bin/run-latest-derp.sh>
    * It logs into Docker Hub.
    * Then pulls the latest derp container.
    * Kills the running derp container.
    * Stands up another derp instance.

I don't like this. I think this is cursed and Rube-Goldberg-esque.

## The Possible Future How

~~build-and-deploy-action: <https://github.com/docker/build-push-action>~~

Don't write the SSH config, use key trust: <https://serverfault.com/questions/856194/securely-add-a-host-e-g-github-to-the-ssh-known-hosts-file>

Using Docker Context and Docker Compose:
<https://www.docker.com/blog/how-to-deploy-on-remote-docker-hosts-with-docker-compose/>

Docker Context: <https://docs.docker.com/engine/context/working-with-contexts/>

Environment Variables in Compose: <https://docs.docker.com/compose/environment-variables/>

Not using Docker Machine: <https://stackoverflow.com/questions/43505196/how-to-deploy-a-docker-container-on-a-remote-ubuntu-server>

[discord]: https://discord.com
[docker]: https://www.docker.com/


I want a chatbot as a personal assistent.

Derp

One Simple Technique to Boost Writing, Learning and Thinking -- for Students, Academics, and Nonfiction Book Writers

How to Take Smart Notes


What should my system be doing for me? How can I better expose my thinking and produce meaningful
results? I've thought before about making paths through the ((digital-garden)) but what would that
look like?

This notes-system is currently my [home-cooked meal][sloan] and not meant for public consumption,
yet.

How does it relate to ((projects/wisps))?

* ~~Mark `draft` notes as such.~~ Table the draft concept for now. Everything here is a draft.
* Look into formatting `code` blocks differently. Syntax highlighting?
* Organize "chains" of notes like [Tom Critchlow does][blogchains]. Do I want the note-system
  running locally to write out these paths for me or show them to me somehow?
* Surface things that have been updated recently to the front.

[blogchains]: https://tomcritchlow.com/2019/07/17/blogchains/
[sloan]: https://www.robinsloan.com/notes/home-cooked-app/


Notes System


## Text

* Trying to put more of my current thinking into my notes and organize them, even a little bit.
* ((projects/wisps))!!

## Code

### Webby stuff

* ((notes-system))
  * Working on a [NextJS]-driven static site that allows for exploring my notes.
  * [The notes site itself][note-site].
* ((projects/wisps))
  * Microbloggy, tumbleloggy thing that is mostly linkspam, written in NextJS and hosted on Vercel.
    Super-addictive combo, them.
  * [The wisps site itself][wisps].
* ((projects/linky))
  * Link shortener using ((cloudflare-workers)).
  * Short and sweet, put together in about an hour.
* ((projects/derp))
  * The PA chatbot.

### Video games

* [Gemini Rising][gr]
  * On ~~brief~~ hiatus while I work on games that won't take me four more years to complete.
  * Need to write about that hiatus.
* [Beehive.lua][beehive]
  * Released at <https://github.com/drhayes/beehive.lua>
* ~~Surrender~~
  * A short game that is entirely a boss fight from an earlier game.
  * On hold.
* [Squeak.lua][squeak]
  * A lua framework for making games.
* [Generic Platformer][platformer]
  * Example LÖVE codebase using proto-Squeak and proto-Squick.
* Squick.lua
  * Don't like that name.
  * Keyboard-accessible UI framework.


[gr]: https://drhayes.io/games/gemini-rising
[platformer]: https://github.com/drhayes/generic-platformer/
[squeak]: https://github.com/drhayes/squeak.lua/
[beehive]: https://github.com/drhayes/beehive.lua
[nextjs]: https://nextjs.org/
[wisps]: https://wisps.drhayes.io
[note-site]: https://notes.drhayes.io


Projects


I don't like Twitter. I deleted my account a few years ago and I'm never going back.

Their irresponsible policies around mass moderation and emphasis on lowest-common denominator,
widest-possible distribution and interest hoovering make them more of a bullying and marketing
platform. No thanks. I want my own place to stick stuff that I'm looking at that isn't stuck in
someone's database to scrape and analyze while manipulating my brain's dopamine production to boost
some "engagement" stat.

What would that look like, given that I'm not really looking for a place to connect to people
(Mastodon?) but more of a "check it out" place that doesn't annoy people too much?

And of course my random experiment is running on NextJS and Vercel. Very addictive combo.

Inspired by <http://leahneukirchen.org/trivium/> and <https://leahneukirchen.org/anarchaia/> before that.

* Next:
  * RSS.
  * About page?
  * Tags?
  * Definitely music.
  * Definitely images.


Some notes about the microbloggy tumbleloggy thing I'm working on.

#text