Introducing Gavos 1.0: A Command Line for gavinj.net Source

1---
2title: "Introducing Gavos 1.0: A Command Line for gavinj.net"
3date: "2026-05-24"
4published: true
5tags: ["gavos", "blog", "command-line", "javascript", "php", "codex", "search", "tools"]
6author: "Gavin Jackson"
7excerpt: "Gavos 1.0 adds a retro command line interface to gavinj.net, turning article search, navigation, source viewing, IPython, network tools, and a few useful Unix-style workflows into something playful and practical."
8---
9
10# Introducing Gavos 1.0: A Command Line for gavinj.net
11
12![Gavos console preview](/assets/gavos-console-preview.svg)
13
14I had a fairly simple idea: what if my blog had a useful command line?
15
16Not a fake terminal that only prints a joke and then runs out of ideas. Not a decorative "hacker" overlay that looks interesting for five seconds and then does nothing. I wanted something that actually helped me move around the site, search articles, inspect content, and run a few useful tools.
17
18That idea became **Gavos 1.0**.
19
20It is a retro-style console built into gavinj.net. **Press the backtick key**, and a black-and-green terminal drops down from the top of the page. From there, the site starts to feel a little less like a blog and a little more like a tiny Unix system made out of posts, pages, tags, and tools.
21
22That is extremely unnecessary.
23
24It is also exactly the kind of unnecessary that makes a personal website feel personal.
25
26## Why Add a Console to a Blog?
27
28The practical reason was search.
29
30The site already had normal navigation, tags, post pages, and a search interface. But I kept thinking about how much of my working life happens in terminals. If I want to find something, I reach for `grep`, `find`, `less`, `history`, tab completion, and muscle memory. Those tools are fast because they are composable.
31
32So the first version of the idea was modest:
33
34```sh
35search ubuntu
36```
37
38or maybe:
39
40```sh
41find linux
42```
43
44But once the console existed, it was hard not to keep going.
45
46If articles have paths, then `ls` should list them. If `ls` lists them, then `ls | grep ubuntu` should work. If an article has Markdown source, then `cat`, `less`, `head`, `tail`, and `wc` should work. If tags are part of the site, then they should behave like directories. If there is a command line, it should have history, tab completion, manual pages, and a prompt that shows where you are.
47
48That is how Gavos grew from "a quicker search box" into a small command environment.
49
50## Core Features in Gavos 1.0
51
52The public feature set in Gavos 1.0 now includes:
53
54- **Console access**: open the console with the backtick key, close it with `exit`, Ctrl+D, or the close button, and clear the screen with `clear`.
55- **Help and documentation**: use `help`, `?`, and `man` to discover commands and read short manual pages.
56- **Virtual navigation**: move around the site with `pwd`, `cd`, `ls`, and `tree`.
57- **Article and page discovery**: search paths, titles, tags, dates, articles, and standalone pages with `find`, `tags`, and `grep`.
58- **Direct navigation**: use `open` to jump to articles, pages, or tag result views.
59- **Source viewing**: use `cat`, `less`, `head`, `tail`, and `wc` against article and page source.
60- **Pipelines**: combine commands with pipes, including `grep`, `head`, `tail`, `wc`, and `sort`.
61- **Shell comfort**: use command history, `!!`, `!NUMBER`, Ctrl+R reverse history search, tab completion, clickable output, and a prompt that shows the current virtual directory.
62- **IPython in the browser**: start a Pyodide-backed IPython session with `python` or `ipython`, then return to Gavos with `.exit`.
63- **Network and web tools**: run browser-safe versions of `host`, `nslookup`, `ping`, `traceroute`, `whois`, `certcheck`, and `curl -I`.
64- **Utility commands**: use `date` for AEST and other time zones, `diceware` for passphrase generation, and `top` for a terminal-style view of popular articles.
65- **State persistence**: keep console output, history, and current virtual directory available across page loads in the same browser session.
66
67## The Tiny Filesystem
68
69Gavos treats the site like a tiny filesystem.
70
71The prompt shows a fake current directory:
72
73```sh
74gavinj:/posts>
75```
76
77From there, the familiar commands work:
78
79```sh
80pwd
81ls
82cd /pages
83cd /tags
84tree /
85```
86
87Articles live under `/posts`, standalone pages live under `/pages`, and tags live under `/tags`. The illusion is intentionally small, but it is surprisingly useful. A blog already has structure; the console just gives that structure a command-line shape.
88
89An `ls` of posts prints entries in a Unix-like long listing format, including permissions, owner, group, date, path, and title. The post paths are clickable, so the output is not only decorative. You can scan it like terminal output and still use it like a web page.
90
91Tags behave similarly. You can list them, search them, move into them, or open a tag result page directly:
92
93```sh
94tags
95tags linux
96cd /tags/linux
97open linux
98```
99
100That last one opens the normal blog tag view, so the console does not replace the site. It gives the existing site another way to be used.
101
102## Search That Feels Like Search
103
104The console has a few different ways to find things.
105
106For quick filtering, there is `grep`:
107
108```sh
109ls | grep ubuntu
110```
111
112For more structured searching, there is `find`:
113
114```sh
115find /posts -tag linux
116find . -name ubuntu
117find /pages -name resume
118```
119
120The search is not trying to be a giant external search engine. It is more like a site-local discovery tool. It searches article paths, titles, tags, dates, standalone pages, and other metadata that already belongs to the blog.
121
122There is also tab completion for paths, so you do not need to remember full slugs. Start typing an article path, hit Tab, and the console helps finish it.
123
124## Reading Posts From the Console
125
126One of my favourite parts of Gavos is that posts can be treated like files.
127
128For example:
129
130```sh
131cat ubuntu-to-red-hat-enterprise-linux-2026
132less ubuntu-to-red-hat-enterprise-linux-2026
133head -20 ubuntu-to-red-hat-enterprise-linux-2026
134tail -20 ubuntu-to-red-hat-enterprise-linux-2026
135wc ubuntu-to-red-hat-enterprise-linux-2026
136```
137
138That works for standalone pages too:
139
140```sh
141cat resume
142open resume
143```
144
145This is the kind of feature that would make no sense on most websites and complete sense on a Markdown-based technical blog. The article source is already there. Gavos just exposes it in a way that feels natural if you live in terminals.
146
147`less` behaves like a pager rather than just dumping text into the console. You can scroll up and down, use Page Up and Page Down, and press `q` to return to the prompt.
148
149Pipelines work as well:
150
151```sh
152cat resume | head -20
153cat ubuntu-to-red-hat-enterprise-linux-2026 | wc
154ls | grep linux | sort
155```
156
157It is not a full shell, but it borrows enough of the grammar to feel familiar.
158
159## Command-Line Polish
160
161The small details make the console feel much more real.
162
163Gavos includes:
164
165- command history
166- `!!` and `!42` style history expansion
167- Ctrl+R reverse history search
168- tab completion for commands, paths, pages, tags, and article slugs
169- persistent console state between page loads
170- clickable paths in command output
171- `man` pages for the published commands
172- `help` and `?` for quick discovery
173- Ctrl+D and `exit` to close the console
174
175None of those are individually huge, but together they change the feel of the feature. A command line without history or completion feels like a toy. A command line with just enough memory starts to feel like a place.
176
177## A Real IPython Interpreter
178
179The most ambitious feature is:
180
181```sh
182python
183```
184
185or:
186
187```sh
188ipython
189```
190
191That starts an in-browser IPython environment using Pyodide. It supports multi-line Python input, tab completion, auto-indentation, and `.exit` to return to the Gavos shell.
192
193This is wildly overpowered for a blog console, which is part of the appeal. Sometimes I want a scratch Python environment quickly. Now the site has one.
194
195It also fits the spirit of the project. Gavos is not only navigation. It is a small toolbox.
196
197## Useful Network and Web Tools
198
199Because this is a technical blog, it felt right to include a few tools I actually use.
200
201Gavos includes browser-safe versions of familiar network commands:
202
203```sh
204host gavinj.net
205nslookup gavinj.net
206ping gavinj.net
207traceroute gavinj.net
208whois gavinj.net
209certcheck gavinj.net
210curl -I https://www.gavinj.net
211```
212
213Some of these use small PHP endpoints on the server side where the browser cannot do the job directly. For example, `curl -I` needs a proxy because browsers do not expose raw response headers in the same way a terminal does, and certificate inspection needs server-side help to retrieve public TLS certificate details.
214
215The goal is not to replace a real terminal. The goal is to make the blog console useful enough that it earns its place.
216
217There are also a few general-purpose tools:
218
219```sh
220date
221date --help
222diceware -n4 -d-
223top
224top -n 25
225```
226
227`date` shows the current AEST time by default, with options for other time zones. `diceware` generates passphrases from the EFF Diceware word list using browser cryptographic randomness. `top` reads the site's access-log-derived popularity data and renders the most viewed articles in a terminal-style bar chart.
228
229Again, unnecessary.
230
231Again, useful.
232
233## How We Built It
234
235The best part of this project was the way it grew through collaboration.
236
237I did not sit down with a complete specification for Gavos 1.0. The first idea was closer to "can we add a search bar?" Then the search bar moved around the navigation, gained a keyboard shortcut, became a slide-out control, and eventually sparked the idea of a drop-down command console.
238
239From there, it became a steady back-and-forth:
240
241- add the console
242- make the prompt feel right
243- add real commands
244- make search work from every page
245- make pages searchable as well as posts
246- add tab completion
247- make `less` behave like `less`
248- keep console state across page loads
249- make article paths clickable
250- add manual pages
251- wire in IPython
252- add network tools
253- clean up behaviour when navigating away
254- make tags, pages, and articles feel like one coherent content system
255
256That is where Codex was useful. Not because it magically knew what Gavos should be, but because it could keep up with the iteration.
257
258I could describe a behaviour in plain language:
259
260> When I run `ls`, make it look like a Unix file listing, but use my article titles and dates.
261
262or:
263
264> When I type `cat resume`, pages should work the same way articles do.
265
266or:
267
268> Ctrl+R should behave like a proper reverse history search.
269
270Then we could make the change, test it locally, notice the rough edges, and refine it. The workflow felt less like generating a finished product and more like pairing on a feature that kept revealing what it wanted to become.
271
272That style of development suits a personal site. There is room for taste. There is room for whimsy. There is room to say "this is objectively silly, but I like it" and then make it work properly anyway.
273
274## What Gavos Is Not
275
276Gavos is not trying to be a secure remote shell, a server admin console, or a replacement for a real terminal.
277
278It is a website interface.
279
280That matters. Some commands are simulated. Some are backed by carefully scoped endpoints. Some are browser-side conveniences. The Python interpreter runs in the browser, not on the server. The filesystem is virtual. The article source comes from the same Markdown content that powers the blog.
281
282That boundary keeps the feature fun without turning it into an operational liability.
283
284## Why I Like It
285
286Gavos makes the site feel more like mine.
287
288The normal web interface is still there. You can read posts, click tags, use navigation links, and never open the console. Nothing important depends on knowing commands.
289
290But if you are the sort of person who enjoys terminals, there is now another layer waiting underneath the page. It rewards curiosity. It makes the archive more playful. It turns the blog into something you can poke at.
291
292That is one of the things I still love about personal websites. They do not have to be optimised only for conversion, engagement, or a clean product funnel. They can contain small odd features that exist because the person who made the site thought they would be fun.
293
294Gavos 1.0 is one of those features.
295
296It started as an idea for faster search and turned into a tiny command line for the whole site.
297
298I am very glad it exists.
299