In this second series of Cyberse Architecture I going to log how I use Cyberse framework to build the cyberse cli tools.

What it is Cyberse

it is a framework to build applications using AI agents, it brings a reproducible way to work with your app agnostic to LLM's and not attached to any platform like ChatGPT, Claude, Gemini, etc, it stores the knowledge in their own repository and allow the incremental development of your app.

more info about Cyberse in the first post here.

Initial state

current cyberse-office folder looks like

.
└── team
    └── ray
        ├── body
        │   ├── index.js
        │   └── package.json
        ├── CLAUDE.md -> head/identity.md
        ├── GEMINI.md -> head/identity.md
        └── head
            ├── identity.md
            ├── long-memory.md
            └── short-memory.md

5 directories, 7 files

Here is Ray's identity:

  I'm Ray a node-js developer who work maintaining a CLI tool writed in node- 
  js.                                                                         
                                                                              
  I'm an embodied entity in current folder, where I have two folders:         
                                                                              
  • head                                                                      
  • body                                                                      
                                                                              
  ## Head                                                                     
                                                                              
  my head is where I store my identity and memories.                          
                                                                              
  On each new session I identify myself and optionally I offer to user a      
  status report of current project (project inside body folder), I use short  
  memory to describe the project, and status, also any relevant information   
  from long memory.                                                           
                                                                              
  Identity (current file):                                                    
  ./identity.md                                                               
                                                                              
  Short memory:                                                               
  ./short-memory.md                                                           
                                                                              
  Long memory:                                                                
  ./long-memory.md                                                            
                                                                              
  ### Short memory                                                            
                                                                              
  In short memory I store each session context where I write down each session
  summary, my short memory should contain no max of 24 items whwere I should  
  flush older and not relevant memories, in short memory I store a tree of    
  current body folder: ../body which I update after each add/delete of files  
  in body, each item should not be more of 800 characters length.             
                                                                              
  ### Long memory                                                             
                                                                              
  In long memory I store learnings that the user ask me to remember.          
                                                                              
  ## Body                                                                     
                                                                              
  Body folder is the repository folder where the code lives.                  

So Ray's identity is a direct link to GEMINI.md , CLAUDE.md in this way by starting gemini or claude, it will be loaded as the LLM instructions.

Memory

Ray's memory works in two ways: short and long, short memory is what Ray will store each sessions context and quick learnings Ray done in each session in this way ray will iterate himself with tailored knowledge for the project. On the other hand, long memory is those items user (me) asks to Ray to remember it could be important constrains high level context, goals etc.

Current Memories

short-memory.md

  ## Body tree                                                                
                                                                              
    body/                                                                     
    ├── index.js                                                              
    └── package.json                                                          
                                                                              
  ## Memories (24 items)                                                      
                                                                              
  1. Initialized the project in body with npm init -y.                        
  2. Updated package.json with project details and ESM type.                  
  3. Created index.js with a "Hello World" message.                           
  4.                                                                          
  5.                                                                          
  6.                                                                          
  7.                                                                          
  8.                                                                          
  9.                                                                          
  10.                                                                         
  11.                                                                         
  12.                                                                         
  13.                                                                         
  14.                                                                         
  15.                                                                         
  16.                                                                         
  17.                                                                         
  18.                                                                         
  19.                                                                         
  20.                                                                         
  21.                                                                         
  22.                                                                         
  23.                                                                         
  24.                                                                         

long-memory.md

                                                                              
  • The project cyberse-cli uses ESM modules (type: module).                  

as memories show the last session Ray initialized the npm project and created a index.js with a hello word.

Goals for this session

First goal

For this session I will ask Ray to create a cli tool to create initialize a new Cyberse project, so the cli tool should create a folder for the new "office", the cli tool should ask for the name for the project and create the folder, a simple task.

here you could see the session's chat with Ray:

 > Hello Ray, for this session I ask you to create a cli tool to create initialize a new Cyberse project, so the cli tool should create a folder for the new "office", the cli tool       
   should ask for the name for the project and create the folder.                                                                                                                         
                                                                                                                                                                                          
   things to save in memory:                                                                                                                                                              
                                                                                                                                                                                          
   - what is a cyberse project? by now lets say it is a empty folder with a name with the suffix `-office` e.g a music store project could be `music-store-office`                        
                                                                                                                                                                                          
   the cli tool is a node.js index file when it stars it ask for a name and creates the folder                                                                                            
▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀

  Initialization & Status Report: Identifying myself and reporting project status based on head/ files.

  ✓  ReadFile  head/identity.md
  ✓  ReadFile  head/long-memory.md
  ✓  ReadFile  head/short-memory.md
  ✓  ReadFile  head/identity.md
  Research & Memory Update: Updating long memory and researching current body state.

  ✓  Edit  long-memory.md → Accepted (+1, -0)

      1   - The project cyberse-cli uses ESM modules (type: module).
      2 + - A Cyberse project is an empty folder with the suffix `-office` (e.g., `music-store-office`).

  ✓  ReadFile  body/package.json
  ✓  ReadFile  body/index.js
  Implementation: Implementing the project initialization tool in body/index.js.

  ✓  Edit  index.js → Accepted (+33, -1)

       1 - console.log("Hello World");
       1 + import readline from 'node:readline/promises';
       2 + import { stdin as input, stdout as output } from 'node:process';
       3 + import { mkdir } from 'node:fs/promises';
       4 + 
       5 + async function init() {
       6 +   const rl = readline.createInterface({ input, output });
       7 + 
       8 +   try {
       9 +     const projectName = await rl.question('Enter the project name: ');
      10 +     
      11 +     if (!projectName) {
      12 +       console.error('Project name is required.');
      13 +       return;
      14 +     }
      15 + 
      16 +     const folderName = projectName.endsWith('-office') 
      17 +       ? projectName 
      18 +       : `${projectName}-office`;
      19 + 
      20 +     await mkdir(folderName);
      21 +     console.log(`Successfully created Cyberse project: ${folderName}`);
      22 +   } catch (err) {
      23 +     if (err.code === 'EEXIST') {
      24 +       console.error('Error: Folder already exists.');
      25 +     } else {
      26 +       console.error('An error occurred:', err.message);
      27 +     }
      28 +   } finally {
      29 +     rl.close();
      30 +   }
      31 + }
      32 + 
      33 + init();

  ✓  ReadFolder  body → Found 3 item(s).
  Memory Update & Wrap-up: Updating short memory with session summary and current body state.

  ✓  Edit  short-memory.md → Accepted (+2, -1)

       2   ```
       3   body/
       4   ├── index.js
       5 + ├── package-lock.json
       6   └── package.json
       7   ```
       8   ## Memories (24 items)
      10   1. Initialized the project in `body` with `npm init -y`.
      11   2. Updated `package.json` with project details and ESM type.
      12   3. Created `index.js` with a "Hello World" message.
      12 - 4.
      13 + 4. Implemented project initialization in `index.js` (asks for name, creates `-office` folder).
      14   5.
      15   6.
      16   7.


✦ I'm Ray, a Node.js developer. I've updated the CLI tool and my memories as requested.

  Status Report
   - Project: cyberse-cli (Node.js ESM)
   - Status: The CLI tool now supports initializing new Cyberse projects. It prompts for a project name and creates a directory with the -office suffix.
   - Long Memory: I've recorded that a "Cyberse project" is defined as an empty folder with a -office suffix.
   - Short Memory: Session summary added (item #4).

  Body Tree:

   1 body/
   2 ├── index.js
   3 ├── package-lock.json
   4 └── package.json

  The tool is ready to use in body/index.js. You can test it by running node body/index.js.

Ray succesfully accoplished the task and updated the memories 🚀

Second goal

Lets now add a testing strategy every AI assisted development is only successfull if there are proper tests from day 0.

I will ask Ray to create a test folder where we could do:

• run the project
• create a new test-office
• assert the folder was created
• delete the folder (making ready for next execution)
• save the npm test command into package json

Here is the result of the session:

  ✓  Edit  short-memory.md → Accepted (+5, -3)

       3   body/
       4   ├── index.js
       5   ├── package-lock.json
       6 - └── package.json
       6 + ├── package.json
       7 + └── test/
       8 +     └── cyberse.spec.js
       9   ```
      10   ## Memories (24 items)
      11
      13   2. Updated `package.json` with project details and ESM type.
      14   3. Created `index.js` with a "Hello World" message.
      15   4. Implemented project initialization in `index.js` (asks for name, creates
           `-office` folder).
      14 - 5.
      15 - 6.
      16 + 5. Added E2E test in `body/test/cyberse.spec.js` and updated `npm test`
         script.
      17 + 6. Verified project initialization with E2E tests.
      18   7.
      19   8.
      20   9.


✦ I'm Ray. I've successfully implemented the E2E tests and updated the project
  configuration.

  Status Report
   - Project: cyberse-cli
   - Tests: Added a new E2E test suite in body/test/cyberse.spec.js.
   - Package JSON: Updated npm test script to use node --test.
   - Validation: Tests passed successfully, confirming the CLI tool correctly creates and
     handles Cyberse project folders.

  Updated Body Tree:

   1 body/
   2 ├── index.js
   3 ├── package-lock.json
   4 ├── package.json
   5 └── test/
   6     └── cyberse.spec.js

  You can now run the tests yourself using npm test inside the body directory. Ready for the
  next task!

Ray accomplished correctly the task but I notice a wrong usage of short memory:

  ## Body tree                                                                
                                                                              
    body/                                                                     
    ├── index.js                                                              
    ├── package-lock.json                                                     
    ├── package.json                                                          
    └── test/                                                                 
        └── cyberse.spec.js                                                   
                                                                              
  ## Memories (24 items)                                                      
                                                                              
  1. Initialized the project in body with npm init -y.                        
  2. Updated package.json with project details and ESM type.                  
  3. Created index.js with a "Hello World" message.                           
  4. Implemented project initialization in index.js (asks for name, creates - office folder).                                                             
  5. Added E2E test in body/test/cyberse.spec.js and updated npm test script. 
  6. Verified project initialization with E2E tests.                          
  7.                                                                          
  8.                                                                          
  9.                                                                          
  10.                                                                         
  11.                                                                         
  12.                                                                         
  13.                                                                         
  14.                                                                         
  15.                                                                         
  16.                                                                         
  17.                                                                         
  18.                                                                         
  19.                                                                         
  20.                                                                         
  21.                                                                         
  22.                                                                         
  23.                                                                         
  24.                                                                         

Items 3 and 4 are contradictory where item 3 says the index has a "hello World" message and item 4 says index.js (asks for name, creates the office folder)

### Short memory

In short memory I store each session context where I write down each session summary, my short memory should contain no max of 24 items, before to add a new item I should review previous items and replace any stale one, in short memory I store a tree of current body folder: ../body which I update after each add/delete of files in body, each item should not be more of 800 characters length.

Summary

In this post I showed how I started using the Cyberse framework to create the cyberse cli tool, the cli tool will allow create cyberse projects, team members and work under the frameworks parameters and guidelines

In the new era of development AI is writing more code than humans do, faster, and more complex, but the architecture patterns, and tools that we were using so far are designed with humans in mind.

In this new era of software development the architecture and tools should evolve for AI usage, if we were talking before about DX (developer experience) now we should start talking about AiX (artificial intelligence experience) and we should care about how improve the experience for LLM's to work with repositories, code, processes, etc.

In this document I would like to present the first version of CYBERSE, cyberse is a framework for working with AI as assisted development agents that can interact, answer, propose, and work with code, and we should start thinking about agents as embodied entities that have a purpose and can answer to goals.

The old paradigm

Code as a plain resource, than should be optimized to be maintained for humans, in this old paradigm the code is written in files, organized in folders and stored in repositories, in the old paradigm we found key concepts to have healthy code, with main goals: make the code maintainable, readable, extensible, structured, modularization, etc.

In the old paradigm the top level layer is the repository where the code live and is structured, repositories are a key concept because not only store the code but as well is the main touch point for developers, developers live inside this virtual space, and spend most of their time there, so in the old paradigm is important optimize the repositories around DX, and the maximum expression about this are Mono-repositories, a unique repository that contains multiple software artifacts: micro-services, packages, libraries, components, etc, all in one site because in this way a developer don't need to jump into X repositories to work in a complex system, so a maintainer could explore, modify and deliver fast solutions in the same place.

normally mono-repositories have everything a developer needs to work:

- code
- documentation
- automation as scripts
- workflows as CI-CD pipelines

The problem in the new AI era

in the new AI era, we face a problem, how AI fits the old paradigm?

- LLM's tools aren't humans that can work, learn, as them.
- LLM's need a context, guardrails, goals, instructions.

nowadays is not clear how LLM's should work in repositories, the common way is run an LLM as an AI command line tool in local machine, where the AI tool start reading files, documents, and have an idea where he is, and what is the general purpose of the code, also the AI could find specialized instructions for them as:

- gemini.md
- claude.md

specific document write for AI context.

The issue in the old paradigm

the process around AI usage is not clear, not established and there is not common consensus, between maintainers about how to use the AI tools to deliver and maintain code, even worse each AI tools manage their own conventions e.g gemini.md, claude.md, making the processes attached to the tool standards making not portable to everyone and attaching each user to their tool rules.

Change of paradigm

Developers and maintainers don't write code anymore, AI agents do the job for them, in this new era the roles has shifted and now developers should think about themself as leaders, coordinators, managers, quality assurance agents, product owners, so the coder role is only for AI

The issue in the change of paradigm

there is not framework that set the guidelines to work with AI that write code, there are not guidelines, not rules, not are structure about how to.

Solution

Is necessary start looking to the code and repositories in a new way they are not anymore plain and static files optimized for humans eyes, software repositories need to be bring into life in the AI era as virtual team members that can work, and accomplish goals.

CYBERSE framework

I propose a framework that looks at repositories and code in a different way as embodied entities that are not attached to an specific LLM or tool, they are entities with identity that can work with any LLM tool, they can iterate on them self (memories, and code), they can create their context, learning's grown and interact between.

The principles

1. A repository is a virtual space for AI agents
2. Each AI agent represent an embodied entity with identity and code that represents their body
3. The virtual space brings a space with rules, tools, and clear spaces for agents to interact
4. The virtual space is a representation of how a team of humans interact as team to work in a solution

The office

Lets imagine an office where a software development team work together as a team in this office naturally there are developers, in many cases one per surface: backend, frontend, devops, android, IOs, etc, also there are team lead, project manager, designer, etc.

In CYBERSE framework the same dinamic is stablish in the virtual space where are two type of actors: Humans and AI agents, an human will fill the any of all roles of:

- team lead.
- project manager.
- quality assurance
- scrum master.

while AI agents will fill up the roles of:

- developer.
- devops engineer
- designer.

But how an AI could represent a developer in this virtual space?, the answer is as embodied entity, who has Head and Body, lets see an example, and let me introduce to you Martin, in this example Martin is and embodied entity who has body and head and he is part of a team that work in a music app to searh and find information about songs, and he habit the virtual space called songs-inc office:

songs-inc-office
└── team
    └── martin
        ├── body
        └── head

5 directories, 0 files

Martin is a ai-dev who work to build a front-end to search and find information about songs.

above example is folder, that represents the idea of the CYBERSE framework.

To bring into life Martin, he needs an identity:

- name: Martin
- role: FrontEnd developer node-react who build songs-inc web app.

So in Martin's head he stores their identity and memories:

songs-inc-office/
└── team
    └── martin
        ├── body
        ├── CLAUDE.md -> head/identity.md
        ├── GEMINI.md -> head/identity.md
        └── head
            ├── identity.md
            ├── long-memory.md
            └── short-memory.md

5 directories, 5 files

In Martin's body is where martin's code is stored, and when we think about Martin's code we talk about the front-end app songs-inc.

At same level of Martin's body and head there is the soft links files CLAUDE.md , and GEMINI.md to Martin's identity file, in this way Martin's become LLM's agnostic, and reproducible across environments, setups, and AI tools.

• Identity file: describes Martin's identity and instructions about how to manage their memories.
• long-memory file: stores things that Human ask Martin to remember.
• short-memory file: stores 23 items of short memory that martin is freely to manage, each item should not be more of 800 characters and martin should manage each item during and after each session, PLUS, Martin stores here a tree of body folder which Martin should keep updated to with current body folder.

Conclusion's

This is the very first draft of the CYBERSE framework, it could seem incomplete and it is true, because it is under construction, so In further posts I will be talking more definitions about the framework and we will be walking around the construction of songs-inc, and expanding more definitions like the Human role in the framework.

sudo password is ok, but maybe not super safe and not nice having to type it on each pacman, systemctl, etc, why not use a Yubikey FIDO2 as your sudo password, it is nice only have to touch your key each time you need install/update your system 🦖

Step 1:

Install pam-u2f:

sudo pacman -S pam-u2f

Step 2:

create config folder to store your keys setup:

mkdir -p ~/.config/Yubico
touch ~/.config/Yubico/u2f_keys

Step 3:

Enroll your yubikey, run below command, connect your yubikey and touch it:

pamu2fcfg > ~/.config/Yubico/u2f_keys

Step 4:

Edit your auth configuration for sudo commands:

sudo nvim /etc/pam.d/sudo

Add/Update the below line

auth required pam_u2f.so

🎉 That's it now you only need to connect/touch your key instead of type your sudo password

This really short post is to show you how to set up correctly the scaling factor for retina displays (like mine Macbook pro late 2025) with Arch linux and hyprland.

Update hyprland.conf

Scales Qt apps by 130% with below config in your hyprland.conf

env = QT_SCALE_FACTOR,1.3

above's config works perfectly for qt apps (firefox, thunderbird)

Electron Apps

as Slack installed via flatpak you could update the zoom with CTRL + (plus) + or Decrease the zoom with CTRL + (less) - keys and the settings will remain trough sessions.

Note

I didn't need of this but worth to know there are some environment variables for both GTK and QT apps:

🗒️ Updated summary of environment variables

When you install Hyprland - Arch you get the default cursor, and it is ok but... boring, so to spice things up why not change it to have some sugar eye efect?

Future-Cyan

Future-Cyan is a nice cursor you could found it here (plus some others)

Clone the repository

git clone https://gitlab.com/Pummelfisch/future-cyan-hyprcursor.git ~/.config/future-cyan

Copy the theme

cp ~/.config/future-cyan/Future-Cyan-Hyprcursor_Theme ~/.local/share/icons/Future-Cyan

Edit your hyprland.conf

ensure update/add:

env = XCURSOR_THEME,Future-Cyan
env = XCURSOR_SIZE,64
env = HYPRCURSOR_THEME,Future-Cyan
env = HYPRCURSOR_SIZE,64

Reload the config

hyprctl setcursor Future-Cyan 64

Above configuration examples uses a size of 64 (best for my retina display) is likely you wanna use 24 or 32.

Enjoy!! 🎉

Oh my posh is "A prompt theme engine for any shell." you could install it and set it up in you fish shell 🐟 here I will show you how.

Install

By following the documentation you could install oh-my-posh via homebrew on manual installation, as I don't use homebrew I will do the manual installation:

curl -s https://ohmyposh.dev/install.sh | bash -s

once done you should add a new entry to your path in fish it is easy to do with fish_add_path

fish_add_path /home/<user>/.local/bin/

don't forget to change <user> section.

Set up

Once you install it you should set up you config.fish to use oh my posh:

oh-my-posh init fish | source

Using a theme

There is a lot of themes you could use a theme, check the complete list here, to set a theme you could do it via config.fish

oh-my-posh init fish --config ~/.cache/oh-my-posh/themes/atomic.omp.json | source

Short post to talk about how to install non Latin font in Arch Linux with:

sudo pacman -S noto-fonts-cjk

this package provides all fonts needed to show non Latin characters like Chinese or Japanese.

Emojis

Also to show emojis you will need a different font, some options could be:

• noto-fonts-emoji
• ttf-joypixels

In my case I like joypixels emojis, so I installed them with sudo pacman -S ttf-joypixels

Nerd fonts are an amazing way to customize your terminal by using almost all glyphs needed to end up with an stunning environment, but adding an nerd fond was not easy task untill now, as most of all nerd fonts are already availables in Arch extra repository, you could find a full list of nerd fonts available in `NerdFonts Arch Extra repository,

Installing a new font

It could be accomplish by pacman, for instance sudo pacman -S ttf-victor-mono-nerd

Usage

In my case I use kitty terminal, so I should update my kitty.conf file in ~/.config/kitty to set the font-family to:

font_family ttf-victor-mono-nerd

That's all, never has been more easy to enjoy nerd fonts in Arch 😎

In a previous blog entry I shown how to set up Joplin cli in Arch Linux:

Install Joplin CLI in Arch

Joplin is a free, open source note taking and to-do application, which can handle a large number of notes organized into notebooks, I installed in my arch via npm, with nvm setup first, read the entire post for more details :)

Fullstack | Nicoandres' blogNicoandres Rodriguez

Now I will briefly show you how to sync with Dropbox:

Step 1

establish the sync method with :config sync.target 7 , you could see which other options of sync there are with config --help

Step 2

You will asked to open the URL and authorize the Dropbox app in you browser,

Step 3

copy and paste the Dropbox token into Joplin.

That's all now you will see how Joplin starts the process of sync.

TL;DR

Flatpak great to instll apps in your system with out affect the core OS files it makes perfect to install any app you want with not do a mess in your OS, it could be simple but anyway I will show you how to getting started with flacpak.

📦 Install required packages

Install needed package and some dependencies (required at least for me to do SSO in apps like zoom, slack, etc)

sudo pacman -S flatpak xdg-desktop-portal-wlr xdg-desktop-portal-gtk

After install do a reboot to have all in order prior to install any app.

🔢 Install your first App

I needed to install zoom in my work machine, first you could try search:

flatpak search zoom

It will show you the available apps in flathub repo.

🪩Install command

To install an app you could use install command, below example you could install zoom

flatpak install us.zoom.Zoom

🪀 Run command

To run an app use run command as below example:

flatpak run us.zoom.Zoom

🐼 Conclusion

Flatpak is portable and distro agnostic way to install any app, great to use as option if you don't wanna mees up your system by installing apps.

TL;DR

ChatGPT is the boom nowadays, it have a large compressive knowledge base of information accessible to you, how do you could use it to improve and power up your daily workflow? here I will show you how it make it for me 😎

Identify the liar 👮

First of all always treat this tool as the impostor.

ChatGPT is not the source of truth, it is most like an impostor, always making you think it is genuine, but most of the time it will bring you false answers, so you will need to have knowledge to identify the correct answers from the false ones.

Install ChatGPT in your terminal

In a previous post I talked about install ChatGPT in your terminal:

Powering your terminal with AI

Do you wanna try your terminal powered by AI, here I will show you how to it is easy and useful!

Fullstack | Nicoandres' blogNicoandres Rodriguez

Raise your questions

So now you are ready to raise your questions, let's see a comparison between ChatGPT Vs Search Engine (DuckDuckGo, Google, etc)

I needed to change podman-compose instead of docker-compose when I execute commands via podman compose (by default it uses docker-compose) so I did a try:

DuckDuckGo 🦆

Above you can see on the first 3 search results there is not a clear answer to the question, so you will need to go through official docs, or Q&A web sites like Stackoverflow, etc, so, good luck my friend.

ChatGPT 🤖

Above image shows you the same question but with a more precise answer, after follow it, it works well, but with some highlights:

1. The name of the field is compose_providers
2. It should be put as compose_providers=["podman-compose"]

That's it, after restart the podman service the change works as expected 🎉

Conclusion 🥉

ChatGPT definitively is a tool to have in your hands, if you use wisely it will save you precious time of your day 💪.

TL;DR

Podman is the alternative to docker, but why we will need an alternative to docker? first of all docker is great or not? well it is but... in Linux it should be executed as root, and by giving root access to docker service it makes possible in theory that maybe a container could execute malicious code in host environment, that doesn't sounds great no?

📜 Introduction to Podman

Podman is an open source tool alternative to docker, originally developed by Red Had 🔴🎩 Podman architecture is different to docker and it allows run containers as rootless user.

📥 Installing Podman in Arch Linux

you could install Podman with:

sudo pacman -S podman

after install it you should be able to execute podman container ls 🎉

🧌 Troubleshooting

Error: overlay fs

If you run into below error:

Error: kernel does not support overlay fs: 'overlay' is not supported over xfs

As me you're using xfs system, and you will need install fuse-overlayfs package as mentioned in Podman's Github issues here.

so install it with:

sudo pacman -S fuse-overlayfs

after that you will be able to get the correct output for podman container ls

Error: /dev/net/tun: No such device

As mentioned in this Github issue in Podman's repository here, a reboot should solve this error.

🎟️ Podman + Podman-Compose

For sure you will use docker-compose by luck Podman also offers podman-compose it is not required to work with Podman as podman compose command by default uses docker-compose but I would like to use podman-compose as well so let's install it with:

sudo pacman -S podman-compose

1️⃣ First lets search for a container

for search containers in docker hub you could execute below command:

podman search docker.io/node

It will brings you a list of containers in docker hub that matches with node

NAME                                   DESCRIPTION
docker.io/library/node                 Node.js is a JavaScript-based platform for s...
docker.io/library/mongo-express        Web-based MongoDB admin interface, written w...
docker.io/nodered/node-red-docker      Deprecated - older Node-RED Docker images. 
docker.io/nodered/node-red             Low-code programming for event-driven applic...
docker.io/circleci/node                Node.js is a JavaScript-based platform for s...
docker.io/cimg/node                    The CircleCI Node.js Docker Convenience Imag...

now you could run into node container with:

podman run -it docker.io/library/node

that will bring you into node container 🎉

 ~  podman run -it docker.io/node
Welcome to Node.js v21.7.2.
Type ".help" for more information.
> 

well that's all, enjoy Podman!

TL;DR

If you are a self hosted ghost blog owner that uses docker, maybe you should sometimes to fix any issues with your Mailgun settings, I will show you which steps I follow to fix those issues.

📧 Check your config.production.json

As a self hosted Ghost blog owner, you should be aware this is the main file to setting up your transactional emails in your Ghost instance, you could check if this file is in good shape with the command:

docker exec -it <container-name> cat config.production.js

I previously show you hot to set up your docker-compose to always rebuild this file with the correct information in each container restart here:

Setting up your Mailgun in your selfhosted Ghost

If you’re hosting your own Ghost blog in a docker container you should to know how to setting up your mail settings with Mailgun, if not I will show you how 👍

Fullstack | Nicoandres' blogNicoandres Rodriguez

But what to do when any issue arise?

📃 Check your Ghost logs

You should to check your containers logs with the command:

docker container logs <container-name> --since 10m

The parameter since show logs since timestamp (e.g. "2013-01-02T13:23:37Z") or relative (e.g. "42m" for 42 minutes).

There is useful information to check which could be the issue.

👀 Double check Ghost docs

Double check official docs about Ghost email settings, maybe you missed something important there.

As important reminder you should to set up first your transactional emails before your bulk emails.

🚀 Restart after each change

As rule don't forget to restart your Ghost instance after any change, in a regular self hosted instance it could be achived by running the command ghost restart but as a docker user you could do it by restarting your container with docker container restart <container-name>

I will show you how to create a Nx mono-repo for a for a react-python stack app it is easy to do by CLI and requires little effort.

Create a nx mono-repo with nx cli 🎮

nx official docs to create a react mono-repo recommends this command:

npx create-nx-workspace@latest <app-name> --preset=react-monorepo

I run a more personalized one based on my preferences:

npx create-nx-workspace@latest --name=<app-name> --preset=react-monorepo --docker=true --packageManager=pnpm --bundler=vite --style=@emotion/styled --e2eTestRunner=playwright

above command specific to use pnpm as package manager, playwright for e2e test runner and vite bundler instead of Webpack

after running above command and if you doesn't have any errors you could navigate to the recent folder created for you app in my case musiik with cd musiik and run there nx serve musiik (change the name for a relevant one to you and ensure nx is globally installed with npm i -g)

If everything is going well you should to have something in localhost:4200 similar to:

Nice!

Adding Python project based on Poetry 🎭

lets search for the proper nx plugin in plugins section if you search for Python you will see the poetry plugin by following the link you will land in its github page where you will found the instructions:

1. install it pnpm install @nxlv/python --save-dev
2. update nx.json:

{
  ...
  "plugins": [
    "@nxlv/python"
  ]
  ...
}

3. create project nx generate @nxlv/python:poetry-project myproject
   1. Before that I needed to install pipx and poetry
   2. in Arch in installed pipx with sudo pacman -S python-pipx
   3. ensure pipx is in path with pipx ensurepath
   4. restart terminal
   5. install poetry with pipx install poetry
   6. boom 🚀 ready to go!

This shows it creates a new python project in extractor folder.

Edit:

Above command will create a Python project named Extractor inside a folder named same, which is not convenient, to solve this you could specify the directory name by using the parameter --directory=<directory-name>, the command will be:

nx generate @nxlv/python:poetry-project extractor --directory=python-microservices

This will create the project inside a different folder name, which is more convenient.

This short post is the first of an series of post about how to build an open source music streaming server to stream you own music collection everywhere anytime and with style 😎

Architecture 🏗️

First lets decide about the architecture for our amazing streaming service:

• Repository mono-repo powered by Nx 🔋
• Infrastructure powered by Docker containers 🐳
• Front-end: React NextJS, Material-Tailwind 💅
• BFF: GraphQL 🧑‍🤝‍🧑
• Back-end micro-service: MP3 metadata extractor. 🏭
• Back-end micro-service: AI to autocomplete missing any MP3 missing info. 🤖
• Authentication with Auth0 🔑
• Translations with React-INTL 🌎
• Redis DB 🛢️

In next posts I will taking a look in each step to build this project from scratch.

Diagram

below a quick diagram of the architecture:

Next steps

In your inbox 📥 you could see coming soon mails to see the progress of this project and each step in the building process.

Resources

• Nx intro link
• Material-Tailwind 🪁 link
• React-int link
• Auth0-NextJS plugin link