Command Book v1.0.52

Released June 22, 2026

What's New

The Claude Code skill now keeps itself up to date

If you've installed the Command Book skill for Claude Code, it now stays current on its own. Each time Command Book launches, it checks the skill in ~/.claude/skills/commandbook/ and, whenever the app ships a newer version, quietly refreshes it in place — so your agent always works from the latest guidance (like the commandbook wait workflow added in v1.0.50) without you reinstalling anything. Skills installed by an older version of the app — which previously had no way of knowing they'd fallen behind — now heal themselves on the next launch. The refresh only happens when the bundled skill is genuinely newer, and it never delays startup.

Bug Fixes

• The downloadable Claude Code skill is current again: The skill bundle on the website (and its SKILL.md) had drifted behind the copy shipped inside the app — it still taught the old until commandbook status …; do sleep 1; done polling loop instead of commandbook wait. It's back in sync, so downloading the skill by hand now gives you the same up-to-date instructions the app installs.

Command Book v1.0.50

Released June 22, 2026

What's New

commandbook wait — block until your command is actually ready

Starting a server and then knowing the exact moment it's ready is part of almost every scripted or AI-agent workflow. The old advice was a hand-rolled polling loop like until commandbook status myserver; do sleep 1; done — but that loop has no timeout (a failed boot hangs forever), can't tell "still booting" from "already crashed," and still needs a separate curl loop, because a process reports running a moment before its port actually starts accepting connections.

commandbook wait <slug> replaces all of that with a single command that returns the instant its condition is met:

• Waits for real readiness, not just liveness. Add --http <url> or --port <n> and wait returns only once the process is alive and the endpoint actually answers — so you (or your agent) can drop the separate curl-retry loop entirely. Localhost http:// URLs are probed over a raw socket, so they aren't blocked by macOS App Transport Security.
• Fails fast. If the process exits before it ever becomes ready, wait comes back right away instead of burning the whole timeout waiting for something that's already gone.
• Has a real ceiling. The --timeout (default 30 seconds) is only a maximum, never a fixed delay — wait returns the moment the answer is known.
• Handles one-shot commands too. A plain wait <slug> also succeeds when a command has already finished cleanly, and propagates a non-zero exit code if it failed; --for stopped blocks until a one-off command completes and hands you its exit code.
• Speaks JSON. --json reports the final state (running, ready, exited, stopped, or timeout), how long it waited, the command's exit code once it has ended, and the live instances — all using the same scriptable, HTTP-flavored exit codes as the rest of the CLI.

This makes Command Book an even better front door for AI coding agents like Claude Code, Codex, and Cursor: an agent can launch a server, wait for it to be genuinely ready, do its work, and stop it — with no orphaned processes and no guessed-at sleep delays. The AI Agents guide, the CLI documentation, and the bundled Claude Code skill have all been updated to lead with commandbook wait.

Command Book v1.0.49

Released June 19, 2026

This release sharpens output capture — the thing Command Book exists to get right. Two fixes, both prompted by a great bug report, make sure you see everything your processes print and that the noise stays out of the way.

Bug Fixes

• A server's first line of output is no longer missing: When a program prints a line and then keeps running — like a web server printing Running at http://localhost:8080 before it starts handling requests — that opening line now appears right away, and any URL in it becomes a clickable link. Previously, Python (and other tools) buffered that first line when their output was captured through a pipe, so it stayed hidden until the process exited, which for a long-running server is never. Command Book now runs your commands unbuffered, so the opening line streams in like everything else. Thanks to Adam Parkin for the detailed report.
• Cleaner output when shell integration is installed: If your shell startup files load terminal shell integration (such as iTerm2's), stray marker lines like ]1337;RemoteHost=… and ]1337;CurrentDir=… could leak into your process output as noise. Command Book now recognizes and strips these escape sequences, so your output stays clean. Colored output is unaffected.
• Accurate "not in PATH" check for CLI Tools: The CLI Tools settings no longer show a false "~/.local/bin is not in PATH" warning when your PATH is configured in less obvious ways (oh-my-zsh, path+=(), sourced files, and the like). Command Book now resolves your real PATH from your login shell.

What's New

Install the Claude Code skill from the File menu

The Claude Code skill installer now lives in the File menu too — install or remove it without opening Settings, right alongside the CLI Tools items.

Improvements

• More timely update checks: Command Book now checks for updates every 4 hours instead of once a day, so fixes like these reach you sooner. Background checks stay silent when you're offline, so the more frequent cadence won't interrupt you.
• Expanded CLI Tools quick reference: The in-app CLI Tools reference now covers the full command set — including details, ad-hoc run --command, the interactive run picker, no-argument status, and stop --all — with notes on the --json, --directory, --name, and --force flags and a link to the full docs.

Command Book v1.0.48

Released June 18, 2026

What's New

Command Book is now first-class for AI coding agents

The last release gave the CLI a truthful view of what's running and a clean way to stop it. This one builds on that to make Command Book a first-class tool for AI coding agents like Claude Code, Codex, and Cursor. Point your agent at Command Book and it runs your dev servers through the same launch → poll → stop loop you do — instead of spawning background processes it forgets about and leaves orphaned, hogging ports.

Install the Claude Code skill in one click

Open Settings → AI Agents and click Install Claude Code Skill to drop a ready-made skill into ~/.claude/skills/commandbook/. It teaches Claude Code exactly how to start, monitor, and stop long-running processes through the commandbook CLI — no prompt engineering required. Install, remove, and status all work just like the CLI Tools installer. Using Codex or Cursor, or prefer to set things up by hand? The new AI Agents guide has a downloadable skill bundle and copy-paste instructions for each tool.

New CLI commands built for agents

• commandbook details <slug> prints a saved command's full configuration — command, pre-command, working directory, environment variable names, and auto-restart — alongside its current run status, in a single call. Add --json for machine-readable output. Environment variable values are never shown (only their names), so the output is safe to hand to an AI agent.
• commandbook run --command "..." runs a one-off command that's fully managed — visible to status and stop — but not saved to your command list, so an agent can launch throwaway processes without cluttering your sidebar. Add --name to address it later and --dir to set its working directory.
• commandbook stop --json now reports exactly what it stopped — each process's slug, PID, name, and the signal that ended it — so scripts and agents can confirm a clean shutdown.

One consistent set of exit codes

commandbook run and commandbook edit now return 404 for an unknown command instead of a generic error, matching status and stop. Every CLI command speaks the same scriptable, HTTP-flavored exit-code scheme, so agents and shell scripts can branch on one set of codes across the whole tool.

Command Book v1.0.47

Released June 17, 2026

What's New

Check and stop your servers right from the terminal

Command Book's CLI can now tell you what's running and shut it down — making Command Book the reliable front door for the long-running servers and dev processes you manage. When you start things through Command Book (from the app or commandbook run), you always have a truthful answer about what's up, plus a clean way to stop it.

commandbook status <name> reports whether a saved command is running, along with its process ID and uptime. Run it with no name to see everything Command Book is currently running, or add --json for machine-readable output that scripts and AI assistants can parse. It also returns scriptable exit codes (0 when running, 204 when stopped, 404 for an unknown command), so you can branch on it directly in a shell script — for example, if commandbook status djangoproject; then ....

commandbook stop <name> stops a running command cleanly. It escalates gracefully — Ctrl+C, then terminate, then force — and signals the entire process group, so child processes (like npm or python workers) are cleaned up too, not just the shell. Use commandbook stop --all to shut everything down at once for a one-command reset of your environment, or --force to skip straight to a hard kill.

Both commands work whether the process was started from the Command Book app or from the commandbook run CLI — there's a single shared view of everything Command Book is managing.

Built for AI-assisted workflows

If you point Claude (or any AI coding tool) at commandbook run instead of letting it spawn its own background servers, it can't leave orphaned processes behind — and it can call commandbook status and commandbook stop to check on and clean up after itself. Command Book becomes the one place that knows what's actually running, so you stop hunting down stray dev servers and fighting port conflicts.

Command Book v1.0.46

Released March 20, 2026

Bug Fixes

• Compound commands with cd now work correctly: Commands that change directories as part of a && chain (e.g., npm run build && cd public && git add -A && git commit -m "Production build" && git push && cd ..) previously failed because Command Book split each step into a separate process — meaning cd public ran in isolation and the directory change was lost before the next step started. Command Book now detects when a compound command contains cd and runs the entire chain as a single shell invocation, preserving directory state across all steps. Commands without cd continue to use the step-by-step execution with per-step output headers.

Command Book v1.0.45

Released March 6, 2026

Bug Fixes

• Watch-mode commands now stay running: Commands that use --watch flags (like npx tailwindcss --watch, npx vite, webpack --watch, nodemon, and similar tools) previously exited immediately after the initial run instead of staying alive to watch for file changes. This happened because Command Book wasn't providing a stdin pipe to child processes — without one, watch-mode tools see an immediate end-of-input signal and exit. Command Book now keeps stdin open so watch loops persist as expected.
• Ctrl+D (EOF) sends proper EOF: The Ctrl+D shortcut now correctly closes the process's stdin pipe to deliver a true end-of-file signal, instead of sending SIGHUP. This matches how Ctrl+D works in a real terminal and is useful for signaling end-of-input to interactive programs like cat, python, or node.

Command Book v1.0.44

Released February 19, 2026

What's New

Faster Switching Between Commands

Switching between commands that have thousands of lines of output is now near-instant. Previously, clicking a different command in the sidebar could cause a noticeable delay (or spinning cursor) while the output was reprocessed. Command Book now remembers each command's rendered output and scroll position, so switching back and forth feels immediate — even with 5,000+ lines of output.

Protocol-Relative URL Detection

Some web servers output URLs without an explicit scheme, using the protocol-relative format //localhost:1313/ instead of http://localhost:1313/. Command Book now detects these and automatically normalizes them to proper http:// URLs so they appear as clickable links in process output and in the detected links dropdown.

Supported formats include //localhost, IP addresses like //127.0.0.1:8080/, and domains like //example.com/path.

Command Book v1.0.43

Released February 10, 2026

What's New

Duplicate Command

Right-click any saved command in the sidebar and choose Duplicate Command... to create a copy. The editor opens immediately so you can customize the name, working directory, or any other setting. Smart name deduplication ensures copies are named logically: "My Command copy", "My Command copy 2", "My Command copy 3", and so on.

Compound Command Splitting

Commands joined by && are now parsed into individual steps and executed sequentially. Each step gets its own visual header in the output, making it easy to see where one step ends and the next begins. This applies to pre-commands, main commands, and ad-hoc commands.

For example, a command like npm install && npm run build && npm start will run each step separately with clear output separation between them.

Bug Fixes

• Pre-command execution fully non-blocking: Pre-commands now use the same event-driven architecture as main commands — process.run() returns immediately and a termination handler chains to the next step. Previously, pre-commands used waitUntilExit() which could freeze the UI entirely (e.g., if git pull hung waiting for a network response)
• Stop and Force Stop kill entire process trees: Stop and Force Stop now terminate the entire process group (shell + child processes like git, npm) instead of just the shell, ensuring hung child processes are properly cleaned up
• Real-time output streaming: Output from pre-commands and intermediate && steps now streams in real-time instead of appearing all at once after the step finishes
• Auto-scroll stability: Auto-scroll now stays engaged throughout blocking step execution instead of losing track when batched output was dumped

Command Book v1.0.42

Released February 6, 2026

What's New

Import Renamed to Restore

"Import Commands" has been renamed to Restore Commands in the File menu and Settings to better communicate that the operation replaces (not merges) the database.

Bug Fixes

• Settings and About windows no longer get lost behind the main window; they now stay anchored above it
• Restored commands now appear immediately in the sidebar and command palette without requiring an app restart
• Stop All button now cancels pending auto-restart countdowns in addition to stopping running processes
• Stop Group button now also cancels pending auto-restart countdowns for processes within a separator group

Command Book v1.0.41

Released February 3, 2026

What's New

Status-Colored Sidebar Selection

Selected sidebar items now display status-colored text instead of plain white, making it easier to see whether a process is running, stopped, or failed while selected.

CLI Working Directory Default

The commandbook new CLI command now defaults the working directory to your current directory instead of the home folder, so new commands are set up where you're already working.

Command Book v1.0.40

Released February 3, 2026

What's New

.env File Support

Import environment variables from .env files instead of entering them one at a time:

• Browse: Click "Browse for .env file or drop here" in the Command Editor's Environment Variables section
• Drag and drop: Drag a .env file directly onto the Environment Variables section
• Auto-import: When creating a new command, .env files in the working directory are imported automatically

Supports .env, .env.local, .env.development, and .env.production (merged in order, later files override). Standard .env format: KEY=VALUE pairs, comments, blank lines, quoted values, and the export prefix.

Quick Edit Shortcut

• Press ⌘E to edit the selected command directly from the sidebar

Released January 27, 2026

What's New

Command Book 1.0.0 is the initial release - a native macOS app for managing long-running terminal commands.

Command Management

• Create, edit, delete, and duplicate saved commands
• Run ad-hoc commands without saving, with history
• Per-command environment variables
• Auto-restart with configurable delay
• Working directory validation
• 40+ technology-specific icons (Python, Node, Docker, databases, etc.)

Process Management

• Full signal hierarchy: SIGINT, SIGHUP, SIGTERM, SIGKILL
• Batch operations: Stop All and Start All
• Restart running processes
• Graceful app termination with 10-second timeout

Output Display

• ANSI color support (8, 16, 256, and 24-bit true color)
• Text styling: bold, dim, italic, underline, strikethrough
• Clickable URL detection
• Multi-line text selection
• Context menu: Copy, Copy All, Clear
• Configurable buffer size (10K to 500K lines)

Sidebar

• Drag & drop reordering with visual indicators
• Persistent sidebar order
• Live resource summary (processes, memory)
• Hover actions: Start/Stop/Restart/Dismiss
• Keyboard navigation
• Visual separators for organization

Command Palette

• Real-time search with highlighted matches
• Keyboard navigation (arrows, Tab to edit, Enter to run)
• Context menus for all actions
• Section headers with count badges
• Running status indicators

Real-Time Monitoring

• Per-process memory tracking via proc_pid_rusage
• Process tree memory calculation
• Live uptime counter
• Human-readable exit code interpretation

Settings

• Four-tab layout: General, Storage, License, About
• Configurable output buffer size
• Terminal appearance settings
• Exit confirmation toggle
• Database export/import with timestamps
• Shell detection display

UI/UX

• Dark mode optimized
• Accessibility labels on all indicators
• Window state persistence
• Smooth animations respecting reduce-motion
• Custom About window