Plausible Enough

A Custom Status Line for Claude Code

Thu, 02 Apr 2026 00:00:00 +0000

Claude Code has a configurable status line that runs a shell command and displays the output at the bottom of your terminal. It pipes a JSON blob to your script’s stdin with session metadata – model info, context window usage, rate limits, workspace details, and more. Here’s what I’m running with.

What it shows

Left to right:

user@host:path – styled to match my zsh prompt, color-coded by hostname
Model – e.g. Opus 4.6 (1M context)
Context window – a 10-character progress bar with percentage, color shifts from cyan to yellow at 75% and red at 90%
Rate limits – 5h:42% 7d:18% showing the 5-hour and 7-day usage windows, also color-coded by severity
Git info – branch name, remote icon (GitHub/Gitea/GitLab), and dirty/clean status

Configuration

In ~/.claude/settings.json:

{
  "statusLine": {
    "type": "command",
    "command": "~/.claude/statusline.sh"
  }
}

Claude Code pipes a JSON object to your script’s stdin on every update. The fields that matter here:

.model.display_name                        # "Opus 4.6 (1M context)"
.workspace.current_dir                     # "/home/andy/projects/foo"
.context_window.used_percentage            # 0-100, pre-calculated
.rate_limits.five_hour.used_percentage     # 0-100, 5-hour rolling window
.rate_limits.seven_day.used_percentage     # 0-100, weekly limit

The rate_limits fields are available for Claude.ai Pro/Max subscribers after the first API response in a session. The context_window.used_percentage is always available.

The script

#!/bin/bash
input=$(cat)

# Extract Claude Code context
MODEL=$(echo "$input" | jq -r '.model.display_name // "unknown"')
CWD=$(echo "$input" | jq -r '.workspace.current_dir // "."')
CTX_USED_PCT=$(echo "$input" | jq -r \
  '.context_window.used_percentage // 0' | xargs printf '%.0f')

# Rate limits from Claude Code (passed in input JSON)
FIVE_HOUR_PCT=$(echo "$input" | jq -r \
  '.rate_limits.five_hour.used_percentage // empty')
SEVEN_DAY_PCT=$(echo "$input" | jq -r \
  '.rate_limits.seven_day.used_percentage // empty')
[ -n "$FIVE_HOUR_PCT" ] && FIVE_HOUR_PCT=$(printf '%.0f' "$FIVE_HOUR_PCT")
[ -n "$SEVEN_DAY_PCT" ] && SEVEN_DAY_PCT=$(printf '%.0f' "$SEVEN_DAY_PCT")

# ANSI colors
DIM='\033[2m'
RESET='\033[0m'
GRAY='\033[38;5;233m'
VERY_DIM='\033[38;5;240m'
CYAN='\033[36m'
YELLOW='\033[33m'
RED='\033[31m'

# Color code context usage
if [ $CTX_USED_PCT -ge 90 ]; then
    CTX_COLOR=$RED
elif [ $CTX_USED_PCT -ge 75 ]; then
    CTX_COLOR=$YELLOW
else
    CTX_COLOR=$CYAN
fi

# Color code rate limits (muted unless high)
rate_limit_color() {
    local pct=$1
    if [ "$pct" -ge 90 ] 2>/dev/null; then
        echo '\033[38;5;167m'
    elif [ "$pct" -ge 75 ] 2>/dev/null; then
        echo '\033[38;5;179m'
    else
        echo "$VERY_DIM"
    fi
}

# Render a progress bar
render_bar() {
    local pct=$1 width=$2 color=$3
    local filled=$(( pct * width / 100 ))
    [ $filled -gt $width ] && filled=$width
    local empty=$(( width - filled ))
    local bar=""
    for ((i=0; i<filled; i++)); do bar="${bar}█"; done
    for ((i=0; i<empty; i++)); do bar="${bar}░"; done
    echo -n "${color}${bar}${RESET}"
}

CTX_BAR=$(render_bar $CTX_USED_PCT 10 "$CTX_COLOR")

# Rate limit string
RATE_STR=""
if [ -n "$FIVE_HOUR_PCT" ] || [ -n "$SEVEN_DAY_PCT" ]; then
    FIVE_COLOR=$(rate_limit_color "$FIVE_HOUR_PCT")
    SEVEN_COLOR=$(rate_limit_color "$SEVEN_DAY_PCT")
    RATE_STR=" ${VERY_DIM}│${RESET}"
    [ -n "$FIVE_HOUR_PCT" ] && \
      RATE_STR="${RATE_STR} ${FIVE_COLOR}5h:${FIVE_HOUR_PCT}%${RESET}"
    [ -n "$SEVEN_DAY_PCT" ] && \
      RATE_STR="${RATE_STR} ${SEVEN_COLOR}7d:${SEVEN_DAY_PCT}%${RESET}"
fi

# Git info
GIT_INFO=""
if git rev-parse --is-inside-work-tree &>/dev/null; then
    BRANCH=$(git branch 2>/dev/null | grep '*' | cut -d' ' -f2)
    if [[ -n $(git status -s 2>/dev/null) ]]; then
        STATUS="✗"
    else
        STATUS="✓"
    fi
    GIT_INFO=" ${BRANCH} ${STATUS}"
fi

USER=$(whoami)
HOST=$(hostname -s)

echo -ne "${USER}@${HOST}:${CWD} ${DIM}|${RESET}" \
  " ${DIM}[${RESET}${CYAN}${MODEL}${RESET}${DIM}]${RESET}" \
  " ${CTX_BAR} ${CTX_COLOR}${CTX_USED_PCT}%${RESET}" \
  "${RATE_STR}${GIT_INFO}"

This is a slightly simplified version of what I actually run – the real one has per-host color theming and git remote icons – but the core is the same. The key insight is that Claude Code now provides used_percentage for both the context window and rate limits directly in the input JSON, so you don’t need to calculate anything yourself or shell out to external tools.

Importing M3U Playlists to Plex & PlexAmp

Wed, 17 Dec 2025 00:00:00 +0000

A working solution as of December 2025

This guide documents a reliable method for importing M3U playlists into Plex so they appear in PlexAmp and other Plex clients. This approach uses Plex’s hidden /playlists/upload API endpoint.

Background

For years, Plex users have been asking for native M3U playlist support. The forum thread “Can Plexamp read and use m3u playlists?” has been ongoing since 2018 with various workarounds proposed. This guide documents an approach that works reliably in late 2024/2025.

What You Need

Plex Media Server running with a Music library
Your Plex Token (authentication)
Your Music Library Section ID
M3U playlist files with relative paths to your audio files
bash, curl, and python3 (for URL encoding)

Finding Your Plex Token

Your Plex token is stored in the Plex preferences file:

# Linux (typical location)
grep -oP 'PlexOnlineToken="\K[^"]+' \
  "/var/lib/plexmediaserver/Library/Application Support/Plex Media Server/Preferences.xml"

# macOS
grep -oP 'PlexOnlineToken="\K[^"]+' \
  "$HOME/Library/Application Support/Plex Media Server/Preferences.xml"

The token looks something like: xYz123ABCdef456GHI

Finding Your Music Library Section ID

Query your Plex server for library sections:

curl -s "http://127.0.0.1:32400/library/sections?X-Plex-Token=YOUR_TOKEN" | grep -oP 'key="\K[0-9]+'

Or visit http://127.0.0.1:32400/library/sections?X-Plex-Token=YOUR_TOKEN in a browser and look for your Music library’s key attribute. It’s typically a single digit like 1, 2, 3, or 4.

The Hidden Upload Endpoint

Plex has an undocumented endpoint for uploading M3U playlists:

POST /playlists/upload?sectionID={SECTION_ID}&path={URL_ENCODED_PATH}&X-Plex-Token={TOKEN}

Important notes:

The path must be the absolute filesystem path to the M3U file
The path must be URL encoded
The M3U file must be readable by the Plex server
Paths inside the M3U should be relative to the M3U file location

M3U Playlist Format

M3U files should use relative paths and start with #EXTM3U:

#EXTM3U
Artist/Album/01 - Track One.mp3
Artist/Album/02 - Track Two.mp3
Another Artist/Song.flac

Creating M3U Playlists

Here’s a bash function to create an M3U playlist for all audio files in a folder:

#!/bin/bash
AUDIO_EXTENSIONS="mp3|MP3|flac|FLAC|m4a|M4A|wav|WAV|ogg|OGG|opus|OPUS|wma|WMA|aac|AAC|ape|APE|aiff|AIFF"

create_playlist() {
    local folder="$1"
    local playlist_name="$2"
    local playlist_path="$folder/${playlist_name}.m3u"

    # Find all audio files recursively, sorted
    audio_files=$(find "$folder" -type f 2>/dev/null | grep -iE "\.($AUDIO_EXTENSIONS)$" | sort)

    if [ -n "$audio_files" ]; then
        echo "#EXTM3U" > "$playlist_path"

        while IFS= read -r file; do
            # Convert to relative path
            rel_path=$(realpath --relative-to="$folder" "$file")
            echo "$rel_path" >> "$playlist_path"
        done <<< "$audio_files"

        file_count=$(echo "$audio_files" | wc -l)
        echo "Created: $playlist_name ($file_count tracks)"
    fi
}

# Example usage:
create_playlist "/path/to/music/Jazz" "Jazz"

Uploading to Plex

#!/bin/bash
PLEX_URL="http://127.0.0.1:32400"
PLEX_TOKEN="your_token_here"
SECTION_ID="4"  # Your music library section ID

upload_to_plex() {
    local playlist_path="$1"
    local playlist_name="$2"

    if [ -f "$playlist_path" ]; then
        # URL encode the path
        encoded_path=$(python3 -c "import urllib.parse; print(urllib.parse.quote('$playlist_path', safe=''))")

        curl -s -X POST \
            "${PLEX_URL}/playlists/upload?sectionID=${SECTION_ID}&path=${encoded_path}&X-Plex-Token=${PLEX_TOKEN}"

        echo "Uploaded: $playlist_name"
    fi
}

# Example usage:
upload_to_plex "/path/to/music/Jazz/Jazz.m3u" "Jazz"

Deleting Old Playlists

When regenerating playlists, you may want to delete old uploaded versions first. Plex assigns each playlist a ratingKey. Uploaded playlists typically have high IDs (>200000), while original smart playlists have lower IDs.

#!/bin/bash
PLEX_URL="http://127.0.0.1:32400"
PLEX_TOKEN="your_token_here"

# Get all playlist IDs and delete those with high ratingKeys
curl -s "${PLEX_URL}/playlists?X-Plex-Token=${PLEX_TOKEN}" | \
    grep -oP 'ratingKey="\K[0-9]+' | while read id; do
    if [ "$id" -gt 200000 ]; then
        curl -s -X DELETE "${PLEX_URL}/playlists/$id?X-Plex-Token=${PLEX_TOKEN}"
        echo "Deleted playlist $id"
    fi
done

Complete Regeneration Script

Here’s a complete script that regenerates and uploads playlists:

#!/bin/bash
#
# Regenerate all music playlists and upload to Plex
# Run this whenever you add or move music files
#

PLEX_URL="http://127.0.0.1:32400"
PLEX_TOKEN="your_token_here"
SECTION_ID="4"  # Music library section ID
AUDIO_EXTENSIONS="mp3|MP3|flac|FLAC|m4a|M4A|wav|WAV|ogg|OGG|opus|OPUS|wma|WMA|aac|AAC|ape|APE|aiff|AIFF"

echo "=== Regenerating Music Playlists ==="

# Function to create a playlist
create_playlist() {
    local folder="$1"
    local playlist_name="$2"
    local playlist_path="$folder/${playlist_name}.m3u"

    audio_files=$(find "$folder" -type f 2>/dev/null | grep -iE "\.($AUDIO_EXTENSIONS)$" | sort)

    if [ -n "$audio_files" ]; then
        echo "#EXTM3U" > "$playlist_path"
        while IFS= read -r file; do
            rel_path=$(realpath --relative-to="$folder" "$file" 2>/dev/null || echo "$file")
            echo "$rel_path" >> "$playlist_path"
        done <<< "$audio_files"
        file_count=$(echo "$audio_files" | wc -l)
        echo "  Created: $playlist_name ($file_count tracks)"
        return 0
    fi
    return 1
}

# Function to upload a playlist
upload_to_plex() {
    local playlist_path="$1"
    local playlist_name="$2"

    if [ -f "$playlist_path" ]; then
        encoded_path=$(python3 -c "import urllib.parse; print(urllib.parse.quote('$playlist_path', safe=''))")
        curl -s -X POST "${PLEX_URL}/playlists/upload?sectionID=${SECTION_ID}&path=${encoded_path}&X-Plex-Token=${PLEX_TOKEN}" > /dev/null
        echo "  Uploaded: $playlist_name"
    fi
}

# -----------------------------
# STEP 1: Create playlists for each folder you want
# -----------------------------
echo "--- Creating playlists ---"

# Add your music folders here
MUSIC_FOLDERS=(
    "/path/to/music/Jazz"
    "/path/to/music/Classical"
    "/path/to/music/Rock"
)

for folder in "${MUSIC_FOLDERS[@]}"; do
    if [ -d "$folder" ]; then
        folder_name=$(basename "$folder")
        create_playlist "$folder" "$folder_name"
    fi
done

# -----------------------------
# STEP 2: Delete old uploaded playlists
# -----------------------------
echo "--- Cleaning up old Plex playlists ---"

curl -s "${PLEX_URL}/playlists?X-Plex-Token=${PLEX_TOKEN}" | grep -oP 'ratingKey="\K[0-9]+' | while read id; do
    if [ "$id" -gt 200000 ]; then
        curl -s -X DELETE "${PLEX_URL}/playlists/$id?X-Plex-Token=${PLEX_TOKEN}" > /dev/null
    fi
done
echo "  Removed old uploaded playlists"

# -----------------------------
# STEP 3: Upload fresh playlists
# -----------------------------
echo "--- Uploading to Plex ---"

for folder in "${MUSIC_FOLDERS[@]}"; do
    if [ -d "$folder" ]; then
        folder_name=$(basename "$folder")
        playlist="${folder}/${folder_name}.m3u"
        upload_to_plex "$playlist" "$folder_name"
    fi
done

echo "=== Done! ==="

Troubleshooting

“localhost” doesn’t work

Use 127.0.0.1 instead of localhost in the Plex URL.

Playlists upload but are empty

Ensure the M3U file uses relative paths from its own location
Verify the audio files exist and are already indexed in your Plex library
Check that Plex can read the M3U file (permissions)

Permission denied errors

Some folders may be read-only. The scripts handle this gracefully by continuing to the next folder.

Finding which playlists to keep

Original Plex smart playlists (like “Recently Added”, “Recently Played”) have low ratingKey IDs. Check your playlists before bulk deleting:

curl -s "http://127.0.0.1:32400/playlists?X-Plex-Token=YOUR_TOKEN" | \
    grep -oP '(ratingKey|title)="[^"]+"' | paste - -

API Reference

Endpoint	Method	Description
`/playlists?X-Plex-Token={TOKEN}`	GET	List all playlists
`/playlists/upload?sectionID={ID}&path={PATH}&X-Plex-Token={TOKEN}`	POST	Upload M3U playlist
`/playlists/{ratingKey}?X-Plex-Token={TOKEN}`	DELETE	Delete a playlist
`/library/sections?X-Plex-Token={TOKEN}`	GET	List library sections

Automation

Add the regeneration script to a cron job to keep playlists updated:

# Run every Sunday at 3am
0 3 * * 0 /path/to/music/regenerate-playlists.sh >> /var/log/plex-playlists.log 2>&1

Or run manually whenever you add or reorganize music files.

This guide was created in December 2024 and confirmed working with Plex Media Server. The /playlists/upload endpoint is undocumented and may change in future Plex versions.

Rails Database Schema Inconsistency

Fri, 24 Jan 2025 00:00:00 +0000

Rails Database Schema Consistency: A Developer’s Guide

aka, Oh no why is schema.rb conflicting all the time!?

How Database Schemas Diverge

“You do it to yourself, you do” – Radiohead

Multiple developers create migrations in parallel branches
Column orders differ due to migrations being run in different sequences
Database restoration from backups followed by migrations
Migrations aren’t rolled back before switching branches
Out-of-band database changes without corresponding migrations

Resolving Schema Differences

Use rails db:prepare as your primary command for database setup (guide)
- Handles both empty and partially migrated states
- Runs schema:load for new databases
- Runs db:seed
For specific scenarios:
- New database: rails schema:load (faster than running all migrations) (guide)
- Existing database: rails db:migrate (guide)
- Complete reset: rails db:reset (drops, creates, and seeds) (guide)
When in doubt the only thing that should be considered the source of truth is the production db:schema:dump. Production is reality.

Prevention Strategies

Development Practices:
- Roll back migrations before switching branches¹
- Roll back migrations before deleting migration files¹
- Write idempotent seed files
- Consider using environment-specific seeds:
```
# seeds.rb
load(Rails.root.join('db', "#{Rails.env.downcase}_seeds.rb"))
```
Tools:
- Consider using fix-db-schema-conflicts gem to maintain consistent column ordering
- Newer versions of Rails includes automatic column sorting in schema dumps (PR)
CI/Testing:
- Consider running db:reset in CI before tests
- Maintaine your seeds.rb file to ensure that it continues to run for developers running (db:reset or db:prepare). I encourage you to write it so that it is idempotent and can be run again on an existing database as well.

Take special care to reset/rollback migrations that you are abandoning, or when switching branches if you are using theannotate gem or similar which will modify potentially many additional files. ↩ ↩²

ruby-oci8 on ubuntu 24.04 with the new libaio1t64

Thu, 06 Jun 2024 00:00:00 +0000

While setting up a new Ubuntu 24.04 LTS machine and trying to install ruby-oci8 v2.2.12 I encountered an issue [1] where it could not find libaio.so.1 [2].

The ubuntu package libaio1 has been replaced with libaio1t64, and ruby-oci8 is not looking for the newly named version of the library libaio.so.1t64 [3]

My solution: simlink to new name to the old one.

sudo ln -s /usr/lib/x86_64-linux-gnu/libaio.so.1t64 /usr/lib/x86_64-linux-gnu/libaio.so.1

Footnotes:

[1] outer stack trace when installing the ruby-oci8 gem without the symlink.

% gem install --clear-sources ruby-oci8                           ± rails-7-1-stable
Building native extensions. This could take a while...
ERROR:  Error installing ruby-oci8:
	ERROR: Failed to build gem native extension.

    current directory: /home/andy/.rbenv/versions/3.3.2/lib/ruby/gems/3.3.0/gems/ruby-oci8-2.2.12/ext/oci8
/home/andy/.rbenv/versions/3.3.2/bin/ruby extconf.rb
attempting to locate oracle-instantclient...
checking load library path... 
  LD_LIBRARY_PATH... 
    checking /opt/instantclient... yes
  /opt/instantclient/libclntsh.so.21.1 looks like an instant client.
checking for cc... ok
checking for gcc... yes
checking for LP64... yes
checking for sys/types.h... yes
checking for ruby header... ok
checking for OCIEnvCreate() in oci.h... yes
checking for OCI_MAJOR_VERSION in oci.h... *** extconf.rb failed ***
Could not create Makefile due to some reason, probably lack of necessary
libraries and/or headers.  Check the mkmf.log file for more details.  You may
need configuration options.

Provided configuration options:
	--with-opt-dir
	--without-opt-dir
	--with-opt-include=${opt-dir}/include
	--without-opt-include
	--with-opt-lib=${opt-dir}/lib
	--without-opt-lib
	--with-make-prog
	--without-make-prog
	--srcdir=.
	--curdir
	--ruby=/home/andy/.rbenv/versions/3.3.2/bin/$(RUBY_BASE_NAME)
	--with-instant-client
	--without-instant-client
	--with-instant-client-dir
	--without-instant-client-dir
	--with-instant-client-include=${instant-client-dir}/include
	--without-instant-client-include
	--with-instant-client-lib=${instant-client-dir}/lib
	--without-instant-client-lib
	--with-sys-dir
	--without-sys-dir
	--with-sys-include=${sys-dir}/include
	--without-sys-include
	--with-sys-lib=${sys-dir}/lib
	--without-sys-lib
<internal:kernel>:307:in `Integer': can't convert nil into Integer (TypeError)
	from /home/andy/.rbenv/versions/3.3.2/lib/ruby/3.3.0/mkmf.rb:754:in `block in try_constant'
	from /home/andy/.rbenv/versions/3.3.2/lib/ruby/3.3.0/mkmf.rb:428:in `popen'
	from /home/andy/.rbenv/versions/3.3.2/lib/ruby/3.3.0/mkmf.rb:428:in `block in xpopen'
	from /home/andy/.rbenv/versions/3.3.2/lib/ruby/3.3.0/mkmf.rb:314:in `open'
	from /home/andy/.rbenv/versions/3.3.2/lib/ruby/3.3.0/mkmf.rb:421:in `xpopen'
	from /home/andy/.rbenv/versions/3.3.2/lib/ruby/3.3.0/mkmf.rb:753:in `try_constant'
	from extconf.rb:34:in `block in <main>'
	from /home/andy/.rbenv/versions/3.3.2/lib/ruby/3.3.0/mkmf.rb:983:in `block in checking_for'
	from /home/andy/.rbenv/versions/3.3.2/lib/ruby/3.3.0/mkmf.rb:344:in `block (2 levels) in postpone'
	from /home/andy/.rbenv/versions/3.3.2/lib/ruby/3.3.0/mkmf.rb:314:in `open'
	from /home/andy/.rbenv/versions/3.3.2/lib/ruby/3.3.0/mkmf.rb:344:in `block in postpone'
	from /home/andy/.rbenv/versions/3.3.2/lib/ruby/3.3.0/mkmf.rb:314:in `open'
	from /home/andy/.rbenv/versions/3.3.2/lib/ruby/3.3.0/mkmf.rb:340:in `postpone'
	from /home/andy/.rbenv/versions/3.3.2/lib/ruby/3.3.0/mkmf.rb:982:in `checking_for'
	from extconf.rb:33:in `<main>'

To see why this extension failed to compile, please check the mkmf.log which can be found here:

  /home/andy/.rbenv/versions/3.3.2/lib/ruby/gems/3.3.0/extensions/x86_64-linux/3.3.0/ruby-oci8-2.2.12/mkmf.log

extconf failed, exit code 1

Gem files will remain installed in /home/andy/.rbenv/versions/3.3.2/lib/ruby/gems/3.3.0/gems/ruby-oci8-2.2.12 for inspection.
Results logged to /home/andy/.rbenv/versions/3.3.2/lib/ruby/gems/3.3.0/extensions/x86_64-linux/3.3.0/ruby-oci8-2.2.12/gem_make.out

[2] inner error in mkmf.log which reveals the issue is with finding libaio1 (I’ve omitted all but the last line, which is the only one that mattered)

LD_LIBRARY_PATH=.:/home/andy/.rbenv/versions/3.3.2/lib:/opt/instantclient ./conftest |
./conftest: error while loading shared libraries: libaio.so.1: cannot open shared object file: No such file or directory

[3] contents of libaio1t64, nothing that exactly matches ‘libaio.so.1’, but that ‘.1t64’ іs close!

% dpkg -L libaio1t64
/.
/usr
/usr/lib
/usr/lib/x86_64-linux-gnu
/usr/lib/x86_64-linux-gnu/libaio.so.1t64.0.2
/usr/share
/usr/share/doc
/usr/share/doc/libaio1t64
/usr/share/doc/libaio1t64/changelog.Debian.gz
/usr/share/doc/libaio1t64/copyright
/usr/lib/x86_64-linux-gnu/libaio.so.1t64

Programming Ruby 3.3

Fri, 26 Jan 2024 00:00:00 +0000

I’ve just received my copy of Programming Ruby 3.3. The original edition of this book is how I first learned ruby years ago. I’ve been following along with all the releases since then, but I wonder if there are any dusty corners that have escaped my notice. This is a language I enjoy using, so I’m pleased to take this occasion to brush up on it.

RubyMine Coverage Gutter Issue (Symlinks!)

Tue, 23 Nov 2021 00:00:00 +0000

I encountered incorrect code coverage highlighting in RubyMine when project was opened via symlink.

This happens because The project files were stored in /actual/project/path, but a symlink to this location was created at /symlink/path. Opening the RubyMine project via the symlink caused a mismatch between the real file paths and the paths stored in SimpleCov’s coverage data.

Specifically, SimpleCov expanded the paths to their full real locations (e.g. /actual/project/path/file.rb) while RubyMine saw the symlinked path (e.g. /symlink/path/file.rb). This caused RubyMine to be unable to match the files to their coverage data, resulting in missing or incorrect highlighting.

The root cause was accessing the project via symlink rather than the real file path. To resolve, reopened the project directly via /actual/project/path instead of the symlink.