DEV Community: Migsar Navarro

Astro + Decap in 2026

Migsar Navarro — Tue, 13 Jan 2026 09:20:12 +0000

This morning I finally started working on a project I had been thinking about for a while, an easy to maintain portfolio blog for photography and architecture.

I used this opportunity to explore Decap, which is a git-based CMS that I wanted to try for some time but never took the time to explore. Some years ago I discovered the project while I was thinking in doing something similar.

I really enjoy working with Astro and one thing I've often wished for when writing for my personal blog is a visual interface that reduces the friction to publish content. I like my site to be static, I don't need and don't want to have a db even if it is managed, but I want to have a nice interface to write my posts which is not an IDE or Obsidian, something a bit more customized for my particular blog.

It took a little longer than expected to have things working, so I decided to write this post to help others that are thinking about using the same stack.

From the docs I saw there were two ways of installing Decap, use a CDN version or use a package manager like npm. I decided I wanted to use the second option, but I felt a bit lost, then what? where to import and call the module?

Quick note about auth

I really didn't care about auth at the moment, I just wanted the editor, which is something that makes me believe there is room for another solution in this space, and I didn't wanted to have to create an actual repository for the test, I mean, I do have a local repository, but didn't want to push it to Github or Gitlab.

So I was looking for the minimal installation even if it took longer to get it right.

Basic structure with Astro

Add config.yml in /public. It is needed in public because we are going to use an Astro page for the index, and it will reference files from public root.

# when using the default proxy server port
local_backend: true

backend:
  name: proxy
  proxy_url: "http://localhost:8081/api/v1",
media_folder: "/src/assets/images/uploads"
collections:
  - name: posts
    folder: /src/pages/blog
    label: "Posts"
    fields:
      - label: Title
        name: title
        widget: string

Add /src/pages/admin.astro to have /admin route. This file can be as simple as this:

---

---

<html lang="en">
  <head>
    <meta charset="utf-8" />
    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
    <meta name="viewport" content="width=device-width" />
    <meta name="generator" content={Astro.generator} />
    <title>Astro</title>
  </head>
  <body>
    <script>
      import CMS from "decap-cms-app";

      CMS.init();
    </script>
  </body>
</html>

Explanation

As you can see, the script is pretty much the same code that appears in the docs, but I am giving a bit more context here because I had to spend some time putting the information together, and it can be confusing, at least it was for me. All the information is from the docs and the repositories.

1. Minimal `config.yaml`

It was try and fix. There is a documentation reference for configuration options but it lacks a summary, so it is not very useful for getting started.

Instead of having the config.yml file in /public it is possible to add a <link href="/admin/config.yml" type="text/yaml" rel="cms-config-url" /> tag in the html as described in Configuration options and Astro's Decap CMS Guide. I don't like that option because it spreads configuration across files a little bit more.

2. Local repository

First I tried to use a different backend and saw the test-repo option, it is nice to know things are working, but it is totally ephemeral, so it was not a good solution.

Then I saw the Working with a local repository section, which is just what I needed, but it doesn't say anything about the backend config needed and it was working fine with a config.yml file but it stopped working when I tried the code configuration (which is not relevant for now other than the fact that I presented the "corrected" yaml file), since it used decap-server I looked in that repo and found in the README.md the proxy configuration I presented here.

3. `CMS.registerPreviewTemplate`

This mysterious line appears in the Install Decap CMS section and later again in the Manual initialization, while it is great to know that the registry is available via the CMS object and it works as expected, that information is not really informative for a first time user.

Apparently it is not needed in any case because I ignored the purpose until a few minutes ago. It is described in Customizing Decap CMS -> Creating custom previews and it allows you to register a custom template for a collection. The template is a React component that will render the data from the collection.

This is totally out of the scope of this post, but I think it is relevant if you, like me, don't like to copy code unless you know it is needed: you don't need it at the moment and you can safely skip that line.

4. Running with local repository

This is something that I don't think is explained in the docs, but probably appears somewhere in the architecture section.

When running locally you need some local API, the idea behind Decap CMS is to use git, it doesn't make sense to add other types of management since it would require a lot of effort to create and maintain.

Therefore, when running locally you need to also run a local server at a different port from your dev server and that's what decap-server is for, you can use it with npx decap-server as indicated in Working with a Local Git Repository.

A more encapsulated alternative

Another alternative, which is the one used in an existing but a bit outdated Astro Decap CMS Starter from offical Astro docs (which doesn't mean that the starter is official, it is actually archived because lack of time from the maintainer) is to use the CDN version of the library and even use a static html inside of the /public folder.

From a technical perspective it is not a bad alternative, since Decap will bootstrap itself there is not much to be processed by Astro at build time and the management of the information can be considered completely autonomous from the development.

A more customized version

If you have read so far you will see, that I've already made a few choices, it is a matter of personal preference, but here I present what I consider the best option and why I prefer it over the alternatives.

These are the important parts:

Code configuration instead of config.yml.
No pollution at /public.
Allows for further customization.
Privacy first, git-based but no need to expose access.

I prefer to have everything in a single place, so I created an admin route in /src/pages/admin there is a minimal HTML file that doesn't use the regular layout, doesn't have anything inside the body but a script tag with the code to load and configure Decap, uploads are made into the /src/assets folder so those can later be processed by Astro, and it feels like an automation of my regular flow instead of a different system.

---

---

<html lang="en">
  <head>
    <meta charset="utf-8" />
    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
    <meta name="viewport" content="width=device-width" />
    <meta name="generator" content={Astro.generator} />
    <title>Astro</title>
  </head>
  <body>
    <script>
      import CMS from "decap-cms-app";

      const config = {
        localBackend: true,
        backend: {
          name: "proxy",
          proxy_url: "http://localhost:8081/api/v1",
        },
        load_config_file: false,
        media_folder: "/src/assets/images/",
        collections: [
          {
            name: "posts",
            label: "Posts",
            folder: "src/blog",
            create: true,
            fields: [
              {
                label: "Title",
                name: "title",
                widget: "string",
              },
              {
                label: "Body",
                name: "body",
                widget: "markdown",
              },
              {
                label: "Created",
                name: "created",
                widget: "datetime",
              },
              {
                label: "Tags",
                name: "tags",
                widget: "list",
              },
            ],
          },
        ],
      };

      CMS.init({ config });
    </script>
  </body>
</html>

The manual initialization is described in Customizing Decap CMS -> Manual Initialization. Apparently the line window.CMS_MANUAL_INIT = true is not needed anymore.

The main thing that I intentionally left unsolved for now is authentication, I don't need it and I think that configuring something that I don't need would increase security vulnerabilities and offer little gains.

Building a Language Companion AI Agent

Migsar Navarro — Fri, 12 Dec 2025 05:42:37 +0000

This is a submission for the Google AI Agents Writing Challenge: Learning Reflections

For the last few weeks, I have spent considerable time learning about Google's ADK (Agent Development Kit) and putting together a capstone project for the AI agents course. I decided it was the right time to deep dive into AI and really commit to this project. It was a great time, not only because I found the time to work on some ideas I have had for a long time, but also because I feel I finally was able to catch up with this technology that has been evolving at a ludicrous speed.

Coming from a front-end background (I do a lot of back-end these days, but that's another story), my first thought was to take the time to explore AI agents' user interface and user experience (UI & UX). In particular, I wanted to experiment with finding a way to use different, more specialized interfaces to accomplish specific tasks, without the feeling of having to switch context.

I didn't have a clear idea of what exactly I was going to build, but I am really proud of what I accomplished, an agent that fits into another topic I am currently very passionate about, which is language education.

A language companion

Before this capstone project, I had frequently used AI, but it was totally from the user perspective, with just a few brief incursions into development. I was not happy with the results in either area; it was the usual mediocre but tolerable result, enough to keep going, but not enough to catch your attention.

By now, I had a clear idea about the project I wanted to work on, a problem I've been trying to solve with AI for a few months now: language learning. I started learning Mandarin a few years ago, and I've found AI to be a great companion. One of the drawbacks is that I lose a huge amount of time moving information around, from the conversation to the editor with constant jumps to the browser to look up videos or search for more information. I thought it would be great to have everything in the same place.

I had a hard time getting started. Kaggle didn't help me this time, as a software engineer, it didn't feel right to code in a notebook. I have been using Kaggle for learning, and it is great, but this time was different because I needed to code in it. After a while, it started slowing me down and making it hard to think about the code and all the moving parts.

With Kaggle's notebooks, things usually work out of the box, which is very cool, but they don't scale the way a properly structured project does. The Python in the learning material didn't look so much like the Python in the ADK examples; it seems it is just a matter of presentation, but there are some important runtime changes. Also, there have been quite a few changes in Python, and not being a full-time Python developer, I was not sure what tools to use. I learnt about uvicorn and typed Python for this project. The examples didn't just work on my machine. Ironically, I started by creating a Dockerfile for the project in order to have a clear view of the dev environment and no pollution from outside, which also meant keeping my computer clean.

After spending the first few days struggling with the setup, trying to get it perfect, and not even touching the core of my project, I realized I had to change strategy if I wanted to finish my project in time. So I moved from working on getting the development environment right to getting the prompts right. My first attempt was to use a single agent to get some kind of MVP working, but the quality was not good enough. The reasoning was just fine, but then the agent had some sort of internal conflict with the separation of concerns. So I decided to create sub-agents:

One for inspecting the user's prompt goal
One for getting the meaning
One for getting the vocabulary
Another one for finding common language patterns
And, finally, one to summarize the work of the previous agents.

AI agents are inherently curious, and a small forgotten comment in a function description or some comment in a definition made the agent perform completely differently. For example, at some point, I had something like "English language" not even in the description of the agent but in the docstring for the agent file, so the agent systematically refused to accept sentences that were not in English, because it was intended for the English language, or so it said.

It required a lot of effort to get this last sub-agent right. At the beginning, it didn't properly use the information of the other agents. I solved that problem, and then the root agent was trying to make the summary itself without using the summary the agent had just generated. Other times, it didn't call the sub-agent at all because it considered itself able to summarize the text. At some point, I wrote a conditional sentence that made the agent summarize the summary and totally ignored all the work done by the previous sub-agents.

There are two main flows for my agent:

Asking to explain a phrase.
Asking to explain a topic.

Those may sound similar, but think about the following. When you start with a topic, it is easy to come up with example phrases, but when you start with a phrase, it is not so easy to get back to the initial topic that originated it; there are so many topics that could have been the source of a given sentence.

Now I had the information I wanted, but I still hadn't touched anything related to the interface yet. For a moment, I thought it would be great to have session, state, and long-term memory, and in the course notebooks, it seemed so easy, so I had to give it a try. It was hard to figure out how to configure things like the runner or the session when using the ADK, and I didn't want to sidetrack to that topic, so I had to skip memory and context, at least for the prototype.

I spend a good amount of time exploring the possibilities of a human-in-the-loop pattern and the examples. That was the only mention of such a thing in the course, but it was not at all like the interface change I had in mind. I was thinking if it could be possible to create an interface with this concept, which is formally named elicitation, so I thought the safest way was to use an MCP server to deal with external calls in a coordinated and grouped manner. So I started creating an MCP server.

FastMCP made the task of creating the MCP server incredibly easy. The only pain point was not being able to deploy it to their official cloud service. For now, I am running it locally with the streaming HTTP interface.

It worked like a charm! The ADK picked up the context perfectly and generated the MCP request from the conversation. A page for the quiz was created, and the link was provided so the user could jump into the quiz. Once the user finishes the quiz, they can ask the agent to evaluate it. The answers are saved in an external database for persistence and to allow sharing them. Afterwards, the quiz is mostly graded by the AI agent, which means it is possible to assess open questions, something almost impossible without LLMs.

I am really proud of the result. There is so much more work to do, but I loved the way ADK and FastMCP helped me create most of the boilerplate. I enjoyed coding the agent, and I will continue working on it to make sure it is production-grade sometime soon.

There you have it: an AI-powered language tutor that includes creating quizzes that live outside of the main conversation and are really interactive. The main idea is to have a two-way communication from the conversational AI agent to the quizzes platform and back, the last part will remain as an exercise to the reader... ehem, sorry, as a goal for another time.

The course

The course was structured in a really intuitive way, but I still struggled with one particular aspect: The workflow for using the ADK to build the agents. Kaggle notebooks are an incredible research setup, but they are very different from the environment in which the agent will run in production. Here are some of the questions I found along the way:

How to structure an ADK project?
How to run ADK in Python, or go?
What does the app runner mean? Can I have it in my main project file?
How to configure things in a repository (ex. session, state, and memory)?
How to efficiently test things? Not to evaluate the agent performance, but to work in a section of a multi-agent architecture.

At the beginning, I was trying to build my project as I went along with the course, but it turned out to be impractical, too much information, too little time, and so many unexpected problems. The way I understand agents changed a lot through the course. Initially, I had no clear idea of the building blocks and the possibilities, but I also didn't know how much I knew because of my particular skills and experience. I thought it would be easier, not in a magical sense, but I thought ADK would take care of more things, not that I think it is not necessary, on the contrary, it helps a lot, and taking care of more stuff would mean a trade-off in terms of flexibility.

After the course and the capstone project, my priority list would be as follows:

Understanding agents (flows, agent vs tool, inter-agent communication)
How to code so as not to block yourself in the future? If you have a good perspective, you can start small and grow incrementally without having to restructure the whole project.
- How to think: bottom-up, top-down? How to isolate agents for development?
- MCP, A2A.
Interfaces. In my opinion, it is the most important understated aspect.
Memory and Session. It is foundational, but you cannot get it right if you don't solve the other problems first.
Testing. How to keep a prompt library and implement testing so you don't waste time. Evaluation to have a way to compare previous and current performance.
Deployment. It depends a bit on the structure of the project and the intended interface, but it is frustrating to spend much time building something and discover it is not suited to be deployed as intended.

AI is much more than LLMs

I was completely unaware that such a vibrant and diverse community existed around artificial intelligence. I had started creating some AI-powered software before, and then abandoned the project after a while, feeling a bit lost and disappointed.

This AI agents course was great because it opened a new perspective on how all the pieces of this ecosystem fit together. I think it is worth mentioning that there are many different startups doing many different but complementary things. From the outside, only the big names are heard, but for every detail of the workflow, at least a few different companies are building great products. As my idea evolved, while I was searching for tutorials and ways to make things fit together, I started learning about some incredibly specialized details of the AI ecosystem.

AI is amazing; you really have the knowledge of an expert in any field at your fingertips, but at the same time, you have the naivete of an 8-year-old kid doing her best to prove that she is old enough to do a real job. So, with AI, you need to be more patient and iterate a lot, way more than with usual engineering, even if you think you really have to iterate a lot for usual engineering work.

I think there is a real shift, and something I've not seen mentioned that often is that AI was built by engineers but designed by managers; it is not for the excellent engineer who needs to be more productive, it is, mostly, for managers who can achieve a higher throughput through coordination of several human or digital agents. That's not to start a discussion on whether it is good or bad, just to say that we really need to understand what AI can do for us in practical terms, and that often comes as an improvement through management.

I am convinced it is an exciting time in an emerging area, and there are so many new things to come.

Afterthoughts

At the end, I realized creating agents doesn't simplify building tools at all; it just makes it a different kind of job, for a totally different profile. It may be more enjoyable, because it transforms the tasks from a form we struggle to deal with into a form we are more comfortable using. It makes complex tasks simpler; we just have to ask for them.

It is mentioned that anyone can build with AI. It is true to some extent, since the interface is simplified compared to having to learn artificial languages to express your simpler thoughts, at the same time is also false, because most people have no management skills at all, and the marketing makes them believe it is just talking, while it is not; complex projects remain complex even if expressed as a conversation.

Creating an agent is about thinking like the leader of a team and coordinating the rest of the team to do their job most purposefully and efficiently. If you don't know what you want to achieve, it is easier than ever to get lost because now not only can other humans take the leadership away from you, but machines can too. It is way too easy to sidetrack.

Here are my two main takeaways from the course:

First, management is more important than ever, not less. We often focus on the technical part of state-of-the-art technologies, and end up neglecting the essential part that is managing, not just managing people, but managing time, managing resources. AI is often portrayed as a magical technology that can help us do everything we want, but it is not; it is as good as the prompts we can create for it and the uses we decide to give it. We can create a prompt creator and a task manager agent, but to create a good prompt creator or task manager, we need to go back to step one.

Second, for complex problems, AI agents won't save you time. But don't despair; it can help a lot by transforming the job from one type of job in which humans are not very capable to another one in which we are really good at, which is expressing and sharing our thoughts. Building a good agent takes a lot of time and a systematic engineering approach; the resulting agent will only be as good as the team that constructs it. It is a good idea to use AI to build AI, but it won't save much time; it will just make the task more manageable.

A final remark I would like to make. While it is true that human beings' skills are limited, we do have a word or two about the way we shape our society. Thoughts are continuously being re-shaped, and we should care that new generations discover the joy of science, engineering, and many other topics that are currently labeled as difficult or boring. AI agents are incredible indeed, and it's precisely because of that that it is paramount to know how to use and coordinate them with mastery.

First steps with Caddy

Migsar Navarro — Fri, 07 Nov 2025 15:38:08 +0000

As part of my effort to securely host my own Filestash instance I've been playing around with Caddy in an effort to better understand how to use it to serve as a very basic gateway for my server.

Caddy configuration can be quite complex, from what I've seen in other places. Happily, it can also be quite simple and straightforward for the more basic scenarios. In any case, it is good to learn some of the concepts behind caddy's configuration, those will be very helpful for any kind of use case, but I feel the docs can be overwhelming sometimes.

Caddy has three ways of configuring it:

Caddyfile
caddy.json
API

The more expressive format and the one used under the hood is the JSON configuration, but it can be harder to read than the Caddyfile. The API and the JSON file offer more flexibility for automated configuration. In this post I will only discuss the Cadyfile.

It is possible to automatically generate the JSON file from the Caddyfile using a the adapt command that is provided as part of the CLI:

caddy adapt -pc ./Caddyfile

Here, the -p option means pretty, to get the JSON format with newlines and tabs, although I don't really like it since I am used to 2-space indentation, the -c option is to explicitly refer to the file used, if omitted it looks for a Caddyfile in the current directory.

Building blocks of a Caddyfile

The Caddyfile is composed of blocks and directives, you can see a more detailed introduction in caddyfile :: concepts section of the docs. Blocks group directives, and directives are functional keywords, that is, can be translated into actions to take, a list of directives is available here. The last fundamental concept to understand is the matchers, as the name suggests the matchers match something, in Caddy thay can match several different things, like paths, methods, query variables, etc.

With these three things we can do a lot. We will often see three directives in the examples, respond that sends something as a response to the client, reverse_proxy that forwards the requests to another server, and file_server that is for static files server.

Matchers

Now I feel it very intuitive, but I still remember a few days ago I was a bit confused with the concept of a matcher, since I was expecting something more rigid. I was thinking about matching strings, paths in particular, and then considering the rest of the stuff, like headers, cookies, or other request properties, and I think all of this was because that would be the way I would have structured the problem in javascript, or other similar routers for servers in which you have middleware to which a request and a response objects are passed.

Caddy's matchers are way more flexible by placing many of the request properties at the same level as the path, so you can create a matcher for ip, headers, host, path, method, protocol, or query among other things. This allows for an incredible flexibility. You can, for example:

Use paths to decide which server handles it.
Serve a difference response based on ips.
Have different services based on headers or query variables.
Use a host matcher for subdomains
Handle websockets using protocol and headers.

It took me some time to wrap my head around this concept, but once I understood how it worked I was amazed by the simplicity and power it provides.

Super basic auth with a matcher

This is NOT something you should use for production, but I was looking for a quick way to protect my server, and I found that using a header was so straightforward that is not even documented.

Simple HTTP auth is also included by default and it may be more secure, although it is very similar in my opinion, you can also use cookies or ip following the same approach. For me, what was important was not having to create some HTML form and have some server code to process it, but I need to say it one more time, I wanted a quick solution for me as a single user, with my Proof-of-Concept, it is not something I would use for something more serious.


localhost:3000 {
    @protected {
        path /protected/*
        header token here-is-my-token
    }

    respond @protected "I'm protected"
    respond "I'm public"
}

What happens here is that we use a named matcher, the block defined with @protected in one of the respond directives, this works like an if that will only execute when the conditions of the matcher are met.

Caddy, self-signed certificates and Certificate Authorities for web development

Migsar Navarro — Thu, 06 Nov 2025 13:53:04 +0000

This is a very quick post, just to summarize some of the last days findings. Often the answer to the questions is explicit once you know about it, but it is very hard to find out when you don't know what you are looking for.

0. Using Caddy HTTPS for localhost

I have known for a long time that Caddy is good because it offers out-of-box Let's Encrypt (and ZeroSSL) certificates, but I didn't know how to use them, because the last time I tried to use them for development it was a pain. I decided to give it another try.

The first thing to know is that you need to explicitly set localhost for the site in order to Caddy try to use a self signed certificate. It can later try to configure it, but it seems to need to install a library for that, also, I was using Podman as a why to keep my machine as clean as possible, so I didn't want to install the library, I think it is just for the automatic configuration.

1. Where Caddy stores self signed certificates?

I am using containers, and the official Caddy image has some really nice and useful documentation, the problem is I didn't pay attention because I was not aware I was going to use it.

No matter how you installed caddy caddy environ | grep caddy will tell you some information about the data and config directories, look for AppDataDir and AppConfigDir, respectively. For my container I got the following output:

caddy.HomeDir=/root
caddy.AppDataDir=/data/caddy
caddy.AppConfigDir=/config/caddy
caddy.ConfigAutosavePath=/config/caddy/autosave.json
caddy.Version=v2.10.2 h1:g/gTYjGMD0dec+UgMw8SnfmJ3I9+M2TdvoRL/Ovu6U8=

If you are using containers, the documentation says it is important to mount persistent volumes for /data and /config directories, and it is, even if you don't care about the cpu and memory usage, if you create everything each time you will have to configure things again.

The second thing is that by using a named volume for that information, it is easy to use the files from the host without "polluting" your system, at least it will be more explicit if you eventually remove those files.

2. Configuring curl and your browser.

Which file I need to use?

First, it is important to know which file to use, it is /data/caddy/pki/authorities/local/root.crt where pki means Public Key Infrastructure, and we need the public part of the root certificate, I tried to look for the reference where I found it, but I was out of luck.

Firefox

I think it is similar for any browser but for simplicity I'll cover only firefox. You need to open about:preferences#privacy, you need to scroll down until you see Security and Certificates, then click the View Certificates button to open the Certificates Manager, be sure to be in the Authorities tab, then click Import... and select the file.

A new certificate authority from Caddy Local Authority will appear and now you can use HTTPS locally without warnings and additional validation steps.

Curl

For curl we have two ways of working with HTTPS, the proper way, and the workaround.

The workaround is using the option -k --insecure, quick and useful, but it can grow into a bad habit. The proper way is to use the --cacert and point to the same root certificate:

curl --cacert ./data/caddy/pki/authorities/local/root.crt https://localhost:3000/

The only thing to be careful about is the path of the certificate, it would be nice to be able to configure that, in a per project basis, but I'll leave that for later.

Filestash Plugin Tutorial: Auto‑Login to S3 Without Typing Credentials

Migsar Navarro — Sun, 26 Oct 2025 03:54:08 +0000

~~This morning~~ Three days ago I finally got my Filestash plugin working as intended, after a week spending my early mornings working on that. This is just the first step, I am aware of that, and the non-coding part often takes longer than the coding part. The purpose of my plugin is really simple, I wanted to be able to set a back-end account in the configuration, so I don't have to login my s3 credentials every time I want to use the app.

Edit 2025/10/31: Here is the link to my repository.

When I discovered Filestash I really loved its simplicity, sadly, as it often happens, I am discovering it is not so simple under the hood, not a bad thing, just to state some often not told truth, product simplicity very often do not correlate to technical simplicity.

The main reason to write this post is to help others in that regard, contribute to make Filestash a bit more simpler technically, or at least easier to understand.

In my previous post, A very basic plugin for Filestash, I described some of the problems I faced when I got started working with Filestash source code, this post builds on top of that.

Why do I need a plugin?

I've been paying for a s3 compatible storage for a few months, and I really need it, but often I skip using it because of the lack of a UI, there are a few UIs already, but none of them adjust to my needs, so when I came to an open source project like Filestash, I thought it was perfect.

Since I don't think my use case is standard, I'll give you a few more details:

I want to use Filestash as a GUI to manage my s3 compatible object storage.
I want to upload files, particularly photos and audio from a few different sources, particularly my cellphone (I guess it is not that common to use s3 object storage, and probably it is more common to pay for a backup service or for something like Google Photos but hold on, I'll explain).
I want to use the files in my s3 storage seamlessly in web-applications, Jupyter notebooks, and all other sort of network based experiments.

In contrast:

I don't need just a web file manager to move files between computers and the cloud.
I won't be sharing the access to this storage, I'll be the only one using it.
I will be sharing, some of the files I have in the storage, without ever showing Filestash UI.

I've have not found a solution for what I need, and if you know about some nice solution please share it, I would love to hear about it. I need a really simple product totally aligned with my needs because any friction will make me not use it.

One last non-technical but very important reason. I'll do the development myself because I enjoy coding when it has a purpose, and I don't have the budget to hire someone else to do it, nor the patience to manage it.

The problem definition

My problem was:

I need to initialize an s3 backend (although it should be similar for other backends) so I can open the app and I don't have to type the credentials for the backend any time.

I want to avoid this screen by automatically login the user

From previous experiences I knew it was a good idea to take a look at the Github's repository issues, to see if other people have experienced or probably solved the same problem. I didn't find something similar to what I need, there was one open issue but it was really new and didn't have any useful information.

The first step was a quick product inspection, I started by opening the dev tools in the browser and taking a look at what happened when I run the app and do all the stuff manually. It was not as linear as I describe it next but it was not hard at all. As an example of the lack of linearity, just two days ago I suddenly realized I had not explored how the demo app authentication happened.

The demo app actually uses a request to /api/session with the credentials from the home page of filestash so the cookie is created. It is a quick solution that could work but I don't really like it because of two things: the first and most important is that it exposes the credentials, something that I didn't wanted to do, the second is that is not elegant at all (of course this is just my opinion).

Getting started

My initial approach was to skip authorization altogether, just initialize the back-end and directly jump to the files view. It may be possible, but I realized that for that approach to work I would need to edit the core, something really want to avoid. So I decided to find a way to make it work as a plugin, even if I already know compilation was needed to configure the plugin.

I didn't have any idea of what the app flow was, I had an idea of how I would architecture a similar application, but that didn't mean there were not other ways to achieve the same things.

From doing things manually I noticed that the first time I was immediately redirected to /login, but there was no login in the routes, so I assumed it was something in the browser. Then I realized that / was taken care at the end of all the routes in a catch all block. When I filled the form and click the submit button a POST request was made to /api/session.

The user needs to send the storage credentials to the server.

It took me some time to discover the logic for the front-end, partly because it is a custom vanilla-js but react-like solution. At some point I read the discussion about keeping a React app or moving to vanilla-js, I don't like the new solution but hey, with open source is like this.

Routing

The router is located in server/routes.go. There are three routes we care about:

GET /, it uses ServeFrontofficeHandler handler. This is the entry point, I don't want to type a complex path before viewing the content.
POST /api/session, it uses SessionAuthenticate handler and creates a cookie. This route is used when the user submits the credentials in the /login page, which apparently is just a browser view in a SPA.
GET /api/session, it uses SessionGet handler. This is the endpoint the home page hits to know if the user is logged in, or more accurately, if the storage has been initialized, and then to decide what view to show accordingly. If the user is logged in the view will be the filesystem, otherwise it will be the login page.

An important thing to notice is that each one of them uses a different set of middlewares. Most of them are not really important, but as I was trying to understand how things worked I found SessionStart and BodyParser were relevant.

SessionStart injects the session for the request context, so even if a backend has been initialized, some session variables won't be available unless the route uses this middleware.

BodyParser injects the body of the request into the context. Not sure why this is necessary, but it took me a while to figure that the absence of ctx.Body was breaking my code.

Hooks: The best place to inject my code

It was not obvious to me where to put my code. The hooks system is not documented, I already knew the possible hooks, but I didn't know what were the entry points for those, also, at the beginning I didn't know how the server persisted the state.

My initial thought was to use the Onload hook, since I wanted to start the backend before any request and keep it initialized, but then I found that this hook does not inject the App to their handlers, so I was not able to save the initialization once done.

Then I thought about using Middleware or HttpEndpoint, to be honest I still don't know if I choose the right thing, even if my code will impact requests I don't really feel like it is a middleware, it should be run just once at the beginning, but there is an advantage of running it as middleware, and it is that I am able to send the cookie to the front-end once I finished initializing the backend.

So I ended up registering it as middleware but running it only once for the given path, this offers some flexibility but I am not totally happy with this solution.

The journey

My plugin doesn't need to do anything new, and I was aware of that, it was more about discovering where things were being done, and then see how much I was able to re-use, the main purpose was to slightly modify the app flow.

My biggest problem was to define what the flow should look like, with the usual flow you have a session because you have some state that is session dependent, in this case, the storage back-end is user defined, but if I want to have a fixed storage back-end I don't see the need for a session, maybe it is important in the server to keep a connection open for some time for the sake of efficiency, but from the user perspective, you don't need a session anymore. The implicit decision in this case is that the logout button that appears on the top right of the UI is not needed anymore.

The login happens in the server without user input

Authentication

This is a very important topic and one that usually is difficult to understand and to implement properly. I am not an expert in authentication but after ten years working with very different code bases I've seen many different ways to achieve the same things. Often in sub-optimal ways, some times I've helped improve the code, some other times I've not been able to convince the team the current solution is not optimal or even faulty, sometimes, I've only been able to detect the flaws retrospectively, after seeing it properly solved in a different company or after working it for myself in one of my projects.

Filestash offers some authorization middleware, and some authentication middleware, but I didn't manage to configure it properly. Even after disabling absolutely everything, there is the need for a session, both for the sake of efficiency and security. In the code it can be read something like isAuthorized but it refers to the authorization from the point of view of the storage service provider, which could or could not be the same authorization that the app will use. As an example, for my use case, I would like to hide the storage provider authorization from the user of Filestash, which will be just me, al least initially.

This storage authorization is sent to the browser, probably for the lack of another method which would be implemented as part of the authorization or authentication middleware, but while I was exploring the code I didn't find flags to disable this to happen or to make it work in a different way but I am not 100 % sure if it cannot be done or simply I missed it.

Internal state

The app saves everything in the App structure which is defined in server/common/app.go and often injected as the ctx parameter. And important note here is that there is a Context field in the struct but it doesn't seem to be used for the session. Here are the four fields that were relevant for the plugin:

Backend saves a reference to the client used for accessing the storage.
Body is not used directly, but it is used by SessionAuthenticate by including BodyParser as a temporary storage for the POST body.
Session stores the credentials for connecting to the storage.
Authorization stores the same hash that is included in the cookie.

Front-end

At the moment there was nothing to be done, but at some point in the future I would like to add a route and a page to set there the login information and some other session parameters, like deciding in which page or pages inject the cookies, or the home directory for the storage.

The only part that we care about is public/assets/pages/ctrl_homepage.js, this is executed for the home page, that is the / path, and there a GET request to /api/session is done to know if a session already exists.

The plugin does not modify this, but send the cookie in the / request so when the call to /api/session is made the cookie is already there, without ever asking for the credentials, so the files are displayed.

The cookie

Cookies are using to keep track of both the user and admin sessions. There is not much to say in this regard, still I think it is important to create a different section to make it visible. The functions for encrypting and decrypting are included in server/common/crypto.go and the secret used is defined in the settings section of the admin panel.

Conclusion

This is a basic plugin and there are still plenty of room for improvements, the most important thing is that currently this only works for s3 storage, which solves my problem but is very limited compared to the wide range of storage that Filestash support. Another nice thing to have would be a plugin configuration page, but for the moment it solves a problem. The next days I'll work in getting Filestash to work with a reverse proxy (Caddy) and deployed it to production.

Debugging in Go with Delve

Migsar Navarro — Sun, 19 Oct 2025 18:56:11 +0000

I'm not a go developer, yet, although I am considering it more seriously these days. It's been a week since I started working in the Filestash project, I've not yet managed to get things working but in the process I've been learning a bit of go.

At some point I really needed to know the internal state of the application at given times, so I decided to explore how to debug with go. I know that many developers stick to string output, but I've always been a fan of the debuggers, even for javascript, but I don't follow the state-of-the-art debugger news. So it didn't take much time to find about Delve, a really friendly open source go debugger.

I think the documentation could be better structured, but to be fair, I only used it to install it, and after that it was really intuitive and when I needed help I used the help option from the CLI.

Christopher Berge from Applied Go created a nice and more detailed cheatsheet, I will talk very briefly about how intuitive it was for a js developer to use it, and about the things that were not so intuitive.

First, installation was straightforward, I connected to the container instance I am using and installed it directly, I still need to add it to the container file.

As part of a lapsus I wrote break in a source file, just to find a compiler error saying it was not possible to write a break outside a conditional structure or something like that. The easiest way to start Delve was to run it from the directory of the entry-point, in the case of Filestash, it is /cmd, then I run dlv debug, the first time it took some time, but after that it has been really fast.

The breakpoints are added from the CLI without the need to edit the source files, a feature I had never used but its quite nice, you can use the relative path and the line number in the common syntax:

break server/ctrl/session.go:32

Then you need to write continue or c to start the execution, if you want to stop execution you can press ctrl+c at any point. You can quit the program with exit | quit | q and restart execution with restart | r. I think when you just press enter it repeats the last command you used, but I discover that empirically and it may be wrong or incomplete.

Then there are a few handy commands:

pb prints breakpoints
clear n delete breakpoint n
clearall delete all breakpoints
p print a variable or evaluates an expression

There are many more commands, but to be honest, since I am debugging a web app under normal circumstances, mostly to learn about it, I only needed those few comments. I was quite happy using it, and it helped me a lot to move faster than I would otherwise done.

One thing I don't fully understand, but my understanding of go programs is very limited at the moment, is that it seems to use a separated cache/config from the binary program, which is nice, since it allows to experiment freely, but it is something I would love to dig a bit deeper in the days to come.

A very basic plugin for Filestash

Migsar Navarro — Wed, 15 Oct 2025 09:26:57 +0000

This post is about how to create a very simple plugin for Filestash, the plugin does nothing at all but writing a line in the logs, it is not intended to be a guide for plugin development, just to summarize the first steps I didn't found anywhere else so myself or other developers can save a few minutes next time.

A few days ago I published A Docker development environment for Filestash in which I showed how to create a quick and simple development environment for Filestash, a web file manager. As I explore the software, I've been discovering things I would love to document, I think the best way to document it is writing this kind of practical, although very simplistic posts.

I am not a go programmer, so expect comments that may be obvious for developers familiarized with the language.

Why do I need to create a plugin?

Filestash's architecture is modular, and plugins play a huge role. Plugins are used for adding storage types, for authentication, authorization, for handling different types of files, for using different types of servers (starter plugins), etc. I am not 100% sure, but it seems most Filestash tasks are achievable through its plugin system.

The sad part is that I didn't find much documentation about how to customize things. At the beginning I didn't even know how to enable/disable plugins. Eventually this made me create a plugin to try to figure out how the system works.

The entry point: how to enable/disable plugins

Plugins are added to the app in server/plugin/index.go, there you have to add or remove the reference for the plugin package in the imports.

There are things you need to know about imports:

_ is called blank and means that the package is imported for its side effects, that is, the code in its initialization.
. is called a period, and it means that all the package's exported identifiers will be available in the importing package without a qualifier, which usually is the name of the imported package.

One additional note about go is that init is a special function that is automatically executed when the package is initialized. This happens before the main function runs and after all package-level variables are initialized.

In conclusion, to add the plugin we simply need to add it to the imports in server/plugin/index.go, to disable a plugin we can comment out or delete the importing line in this file.

A new plugin

To have a package to import we need to create it, here is the simplest plugin I could think of that has a visible output.

It does one simple thing, write an output line to the logs. Even so, there are some interesting remarks:

The logger is defined in the common package, so we need to import it. We could import fmt instead and use print, to immediately print the text, but it would feel out of chronological order.
If we plainly write the log it won't work because the logger is not ready, the best way to do it is to put our function inside a lifecycle hook for the app, more on this in the next section.

package plg_plugin_example

import (
    . "github.com/mickael-kerjean/filestash/server/common"
)

func init() {
    // Apparently Log is not initialized at this point
    // Log.Debug("Why this is not printed?")
    Hooks.Register.Onload(func() { Log.Debug("My plugin!") })
}

Lifecycle hooks

I didn't find any docs about the lifecycle hooks, so here is a little summary without any detail, and probably with some errors or omissions, from their file server/common/plugin.go, part of the common package.

ProcessFileContentBeforeSend
HttpEndpoint
Static
Starter
AuthenticationMiddleware
AuthorisationMiddleware
SearchEngine
Thumbnailer
AuditEngine
FrontendOverrides
XDGOpen
CSS
CSSFunc
Favicon
Onload
Middleware
StaticPatch
Metadata
WorkflowTrigger
WorkflowAction

Just to be clear, I don't know yet the meaning, use case, or configuration of most of these, I am just listing them to keep them at hand. Some may be self-descriptive but a careful analysis of the code is recommended before using it for serious work.

A Docker development environment for Filestash

Migsar Navarro — Mon, 13 Oct 2025 09:48:21 +0000

What is Filestash?

Filestash is a web file manager that works with many different storage solutions. It provides a way to view, and often interact with the files from a web browser.

I was recently looking for an open-source solution to interact with s3 storage and some AI powered browser suggested Filestash, while it was not exactly what I was looking for I decided to give it a try.

I was pleasantly surprised about its simplicity, and it actually worked out-of-the-box, locally, for my very simple use case. Then I started exploring how to actually deploy it somewhere publicly accessible and that's when the problems started, sort of...

Why do I need a dev environment?

The preconfigured image works very well for a simple scenario, and it can easily be used locally, but then you may realize it has many things you don't need and it may not have some of the things you want. To customize your instance is a bit more difficult since documentation is not updated and some things that appear in the official docs are not actually open-source, and only available for paid customers. That being said, I totally understand the reason for those decisions, particularly nowadays.

So Filestash may not be the best solution if you need something quick that just works, but I like the philosophy behind it, even if I am not in love with the architecture, so I think it is worth to invest a little time exploring and, ideally, supporting the project.

We need a dev-environment even to do little changes like adding or removing plugins, but also to get a better idea of how it works and what can be done.

A simple development environment

Since Filestash already provided a docker image I thought it would be very straightforward for me and other users to move in that direction, also I am not a fan of local development, not for my regular tools, but even less if the development is in a language I don't use that often.

The image provided in Filestash repository has a two problems for development:

It uses several stages. That makes sense for deployment, but not for development.
It clones the repository instead of using the local files, so it is harder to edit and compile to see the changes.

Here is the Containerfile I used, I actually used podman instead of docker.

FROM docker.io/golang:1.25.2-trixie
WORKDIR /app
RUN apt-get update > /dev/null && \
    apt-get install -y curl make > /dev/null 2>&1 && \
    apt-get install -y libjpeg-dev libtiff-dev libpng-dev libwebp-dev libraw-dev libheif-dev libgif-dev libvips-dev > /dev/null 2>&1
EXPOSE 8334

As you can see I didn't copy the files, I just used the latest golang image but referred to it by full version to avoid problems later when it is not latest anymore, and installed all the dependencies required in the original file, I installed the ones in the compile step which are not the same from the running container, for example, I didn't install ffmpeg, since it is not a feature I care about.

Then to build the image use:

podman build -t filestash-dev:20251013 -f docker/Containerfile.filestash-dev

There are two things to notice. First, I prefer to use the date in the versioning of my dev images but it can be named and versioned at will, second, the same applies for the Containerfile it is just a matter of personal preference.

Now we can run the service, for that the following line is used:

podman run -it -v .:/app -p 8334:8334 filestash-dev:20251013 /bin/bash

Again, there are a few important things to discuss:

Current local directory is mounted in /app, it is the same as the used in WORKDIR for convenience. The output will be created in the same directory, so it will exist even after the container is destroyed, but the cache used to build won't.
We need to include the port in which our service will run so it is reachable outside of the container.
I executed /bin/bash so I can run the commands in the terminal inside the container. I actually use VSCode to edit the code but locally, not inside the container. These days there are many ways to do it and container integration in VSCode is great, but it is up to you to decide the best workflow.

Afterthoughts

This is just a very quick and simple configuration, there are some shortcomings, at least for me, like being able to keep the bash history, which is not hard to do using container volumes, but it is a good starting point that leaves things open enough to suit several workflows.

Change the default application for Ubuntu's terminal launcher

Migsar Navarro — Sat, 29 Apr 2023 20:04:21 +0000

This is something I has been trying to accomplish for a long time, maybe six months now. I started looking for it, then find a dead end and leave it untouched for a few weeks. This morning I decided it was distracting me enough so I really have to find it. It ended up being simpler than I thought, sadly the answer is not obvious and there are so many misleading pages out there.

About a year ago I bought an amazing laptop, a tuxedo computer with their recommended OS installed, I must say I am quite happy with the laptop, and definitely think it is worth it. It came with Tilix preinstalled as the terminal, which is really nice I must admit, and I would love to explore at some point in the future (no commitment here), but the moment I learned about Alacritty I fell in love with it.

So I am used to Ubuntu's <Primary><Alt>t to open the terminal, and from time to time I use the Open in Terminal from the file explorer and I wanted to properly configure my system, with no overrides or symbolic links to use Alacritty instead of Tilix.

After reading a few StackOverflow answers I learned about dconf, I was able to find where to change the shortcut to trigger the action but not how to change the command that was executed by the action, and I was stuck with that problem for a few weeks. Then at some point I read about:

gsettings list-recursively

If you pass no argument it lists all the keys and values. I didn't think about it initially but my answer ended up coming from here. I saved the output of the command in a text file, opened it in vim and search for tilix.

It was that way that I found this four keys:

org.gnome.desktop.default-applications.terminal exec-arg '-e'
org.gnome.desktop.default-applications.terminal exec 'tilix'
org.cinnamon.desktop.default-applications.terminal exec-arg '-x'
org.cinnamon.desktop.default-applications.terminal exec 'tilix'

What I did was totally empirical, so if someone can shed some light about the related concepts I would really appreciate it. No need to install update-alternatives or to alter my system in any other form, just used gsettings to set these four keys and it worked. Since I've no idea if I needed any argument I just set that empty.

gsettings set org.gnome.desktop.default-applications.terminal exec-arg ""
gsettings set org.gnome.desktop.default-applications.terminal exec "alacritty"
gsettings set org.cinnamon.desktop.default-applications.terminal exec-arg ""
gsettings set org.cinnamon.desktop.default-applications.terminal exec "alacritty"

That's it! It worked like charm! Hope it save you some frustration :)!

Use xclip to copy a file to clipboard

Migsar Navarro — Sat, 29 Apr 2023 19:24:19 +0000

This is a very brief post that I want to write here and maybe I'll try to expand later.

I have tried in the past to copy text from a file into the clipboard to paste it in a gist at Github. The easiest way for someone not familiar with the command line is to simply open the file in a regular graphical editor, then select all the text and finally copy it from there.

The thing is, that is not very straightforward, right?

I must admit I've not read the man page for xclip but also, man pages are usually exhaustive but not very concise when you are trying to solve a problem. After taking a look at a few StackOverflow answers and the man page I realize this can be done in a very simple way:

xclip -selection clipboard -i script.js

There are two nice things to notice here that once you know make xclip very flexible:

-selection it can be "primary" (default), "secondary", or "clipboard". Apparently it is not 100% standardized but it is fairly safe to assume that "clipboard" will work in most cases for browser based apps.
-i you don't even have to select the text but you can immediately upload the whole file. For me this is perfect. But I admit there are cases in which selecting some parts would work better.

There seem to be some other very interesting options in the man page, but that will have to wait for later.

Launch AppImage applications from desktop

Migsar Navarro — Fri, 21 Oct 2022 06:31:48 +0000

Cover image by Sergey Kuznetsov.

There are at least three ways of distributing applications in Linux: AppImage, Flatpak, and Snap. Each one of these have different advantages and disadvantages but often it is not that important as a user since the format to use is a decision to be taken by the developer. Some applications already take care of this step for you, in case they don't keep reading, in this post I will show you a way to configure AppImage applications to be available from your desktop.

First I want to say I am not an expert in the subject, it is just a problem I had been facing for some time now and today I decided to spend some time putting the pieces together and documenting my solution, if you happen to know a bit more about the topic I encourage you to leave a note in the comments and I'll be happy to update. First some questions you will probably need to answer at some point.

Where to put the app file?

This is totally opinionated, my only important recommendation is to move them out of the ~/Downloads, ~/Desktop or ~/Documents common folders. I like to use /opt, since I believe it is a nice way to keep things in a place I know I have to look for when moving my things from one computer to another.

How to find mime types?

If you happen to need a mime type for the configuration, you can use this command that will be available in most Linux distros,

xdg-mime query filetype README.md

For a more detailed explanation read How to Determine MIME Type of a File in Linux.

How desktop environments find apps?

Fortunately for us, the users, desktop environments like GNOME adopted a standard configuration file to describe how an application will be displayed in the start menu and later launched, you can read about it in the latest Desktop Entry Specification.

Where are those files located?

One common place to look for these files is /usr/share/applications/, it is good for learning and looking for examples of categories, but probably not a good idea to put your files there. Apparently the recommendation is to use ~/.local/share/applications/ where ~ stand for your home directory. This recommendation makes sense because it is usually better to have system configuration you made contained in your own directory.

Inside of these directories you will find a dozen of files using the desktop extension. Those are just text files that describe how to display and launch your applications.

How does a .desktop file looks like?

As I mentioned above, there is a full specification, but for the sake of learning, I'll show here the file I created for Beekeeper Studio:

[Desktop Entry]
Name=Beekeeper Studio
Comment=Modern and easy to use SQL client for MySQL, Postgres, SQLite, SQL Server, and more.
TryExec=/opt/Beekeeper-Studio-3.5.1.AppImage
Exec=/opt/Beekeeper-Studio-3.5.1.AppImage
Icon=beekeeper-studio
Terminal=false
StartupWMClass=Beekeeper
Type=Application
Categories=Development;
Keywords=sql;db;database;
X-GNOME-UsesNotifications=true
X-GNOME-SingleWindow=true

To be honest I don't know if all lines are valid, I used another file as a template and left most properties that seemed to make sense.

One important note is that the Icon refers to an icon I downloaded from the project's Github repository and placed in ~/.local/share/icons/beekeeper-studio.png, I saw in StackOverflow that svg seemed to be valid, but didn't try that. About the Category I just copied it from another entry as well, but in this answer you can read a bit more about it.

Why not use an automated method?

There seem to be two ways of doing this automatically and are explained in AppImage's documentation for desktop integration.

Probably those are better suited, but I was looking for something very straight-forward and the description there was not something like copy & paste solution, it implied more reading, and after seeing that Alacritty included the desktop file I thought it was way easier to just type a few lines in a text file instead of reading documentation and installing another thing in my system.

While I was looking for how to do it, I came to some YouTube videos, while I am not much of a video guy I did use some of the description as confirmation of what I was doing, and I think it is probably worth watching them, so here are the links:

How to use AppImages and Integrate them into your system

HUGE Speed Differences! Flatpak vs. Snap vs. AppImage

If you found this information useful, please give it a like to let me know you care and continue writing. You can follow me here or in Twitter to keep you informed when I write a new post.

Installing Alacritty without installing Rust

Migsar Navarro — Tue, 21 Jun 2022 18:44:20 +0000

A week ago I came to the Alacritty's project homepage, again, and I wanted to install it, again, but was discouraged by reading that I had to build it.

I used to build things back in the days (I won't say I was really into compiling things from source, but I am old enough to have lived in a world before i , but more and more I prefer the convenience of just installing things without having to install all the dev tools in my machine.

In Rust's Docker image description you can find a section entitled Compile your app inside the Docker container, which is precisely what I wanted to do, but there will be a problem since two lxcb libraries are not included:

  = note: /usr/bin/ld: cannot find -lxcb-shape
          /usr/bin/ld: cannot find -lxcb-xfixes
          collect2: error: ld returned 1 exit status

error: could not compile `alacritty` due to previous error

I had already started with this, so I'll depart a bit for some config, but it is essentially the same.

Instead of using the image to run cargo directly open a shell console.

docker run --rm -it -v (pwd):/backup rust /bin/bash

Update sources and install lxcb dev libraries.

# You are already root inside the container
apt-get update

# This is the only lib missing from Alacritty's build pre-requisites
apt-get install libxcb-xfixes0-dev

# Now compile, you can use the more concise command from Rust's image description
cargo install alacritty
# I mounted my home dir as /backup
cp /usr/local/cargo/bin/alacritty /backup/alacritty

Outside of the container you need to copy alacritty to some directory included in your PATH, I used:

sudo mv alacritty /usr/local/bin/alacritty

One final notice is that, as stated in the build instructions, this won't install the terminfo file, desktop entry, manual page or shell completions, but shouldn't be hard to get that working.

DEV Community: Migsar Navarro

Astro + Decap in 2026

Quick note about auth

Basic structure with Astro

Explanation

1. Minimal config.yaml

2. Local repository

3. CMS.registerPreviewTemplate

4. Running with local repository

A more encapsulated alternative

A more customized version

Building a Language Companion AI Agent

A language companion

The course

AI is much more than LLMs

Afterthoughts

Links

First steps with Caddy

Building blocks of a Caddyfile

Matchers

Super basic auth with a matcher

Caddy, self-signed certificates and Certificate Authorities for web development

0. Using Caddy HTTPS for localhost

1. Where Caddy stores self signed certificates?

2. Configuring curl and your browser.

Which file I need to use?

Firefox

Curl

Filestash Plugin Tutorial: Auto‑Login to S3 Without Typing Credentials

Why do I need a plugin?

The problem definition

Getting started

Routing

Hooks: The best place to inject my code

The journey

Authentication

Internal state

Front-end

The cookie

Conclusion

Debugging in Go with Delve

A very basic plugin for Filestash

Why do I need to create a plugin?

The entry point: how to enable/disable plugins

A new plugin

Lifecycle hooks

A Docker development environment for Filestash

What is Filestash?

Why do I need a dev environment?

A simple development environment

Afterthoughts

Change the default application for Ubuntu's terminal launcher

Use xclip to copy a file to clipboard

Launch AppImage applications from desktop

Where to put the app file?

How to find mime types?

How desktop environments find apps?

Where are those files located?

How does a .desktop file looks like?

Why not use an automated method?

Installing Alacritty without installing Rust

1. Minimal `config.yaml`

3. `CMS.registerPreviewTemplate`