Command Book v1.1.53

Released July 31, 2026

What's New

The CLI is fully scriptable — your agent can save commands, not just run them

Command Book's CLI could already do almost everything from a script: list, run, status, wait, stop, and details were all built for automation. Two commands were the exception. commandbook new and commandbook edit only worked as interactive prompts, which meant an AI agent setting up a project could run things for you, but never save one for you to reuse later. Ask an agent to "get my dev servers going" and you'd get the servers — and nothing in your command list the next morning.

That gap is closed. Pass flags to new and edit and they skip every prompt and never read from stdin:

commandbook new --name "API Server" \
                --command "uv run flask --app app.main run --port 5000" \
                --dir ~/src/api --icon flask --auto-restart

Run them bare and they still prompt exactly as they always have — nothing about the interactive experience changed.

new takes the full set of options you'd expect: --dir (which sensibly defaults to the directory you're standing in), --pre-command, repeatable --env KEY=VALUE, --auto-restart with --restart-delay, and --icon to pick the sidebar icon yourself. --if-not-exists makes a setup script safe to run twice, which is exactly what you want in a project bootstrap. commandbook edit <slug> accepts the same flags, all optional, and changes only the fields you actually pass — so tweaking one thing can't quietly reset the rest. Everything is validated before anything is written, so a typo in a flag never leaves a half-created command behind.

commandbook delete — remove a command from the terminal

Rounding out the set, you can now delete a saved command without opening the app:

commandbook delete api-server

It never stops to ask "are you sure?" — on a terminal or in a script, it behaves identically. Instead of nagging you, it guards the one case that actually matters: it refuses to delete a command that's currently running, because removing the record while its server is still alive would leave you with something holding a port and no name to stop it by. Pass --force and it stops the process cleanly first, then deletes.

Terminal changes show up in the app instantly

Create a command in the terminal and it appears in Command Book's ⌘K palette right away — no restart, no relaunch. Edit one and any running process picks up its new name, working directory, and icon on the spot. Delete one and it's gone from the palette. Previously the app read your command list once at startup and never looked again, so anything the CLI wrote sat invisible until the next launch. Now the two stay in step, which is what makes the scripted workflow above feel like one tool instead of two.

A restarting command is no longer reported as stopped

If you use auto-restart, there's a window between attempts where your process is briefly down while Command Book waits out the restart delay. Command Book used to lose track of the command entirely during that window: commandbook status reported it as stopped, and commandbook stop answered "known but not running" and did nothing — while the process quietly came back a second later and kept running.

This wasn't a rare timing fluke. A crash-looping server spends far more time waiting to restart than it does running, so for exactly the commands that need watching most, the wrong answer was the usual answer. The practical cost was ugly: you'd be told a server was stopped, then the next start would fail with Address already in use against it, and the only way to find the truth was lsof and walking the process tree by hand. That's precisely the PID juggling Command Book exists to remove.

Restarting is now a state of its own:

$ commandbook status api-server
API Server  ● restarting

status and details report restarting (and "state": "restarting" in --json, per instance as well as overall). It still exits 0, because the command is still managed and still coming back — it just isn't serving this instant. When you need "actually answering requests" rather than "alive", commandbook wait --http and --port remain the right tools. And stop now works during the countdown, the same as any other moment.

commandbook run won't quietly start a second copy

Start a command that's already running and run now stops and tells you, instead of launching a second one alongside the first:

$ commandbook run api-server
✖ api-server is already running (pid 71688, up 4m).
  Use --restart to stop it first, or --allow-multiple to run another instance.

It's an easy state to fall into without noticing — background a run, do unrelated work in another terminal an hour later, background it again — and two copies of a dev server fighting over one port is a confusing afternoon. Pass --restart to replace what's running (it waits until the old one is genuinely gone before starting the new one), or --allow-multiple when several really is what you want. Command Book answers this from its own records rather than by probing ports, because what "already up" means is its business, not a guess about your command.

Improvements

• Pick a command's icon from the CLI. --icon accepts a command type — python, docker, granian, postgres, and dozens more — so a scripted command arrives with the right icon already on it instead of needing a trip to the GUI. Leave it off and Command Book keeps detecting the icon from your command text as before. Pass something it doesn't recognize and it prints the full list of valid types rather than failing silently.
• --json on every write. commandbook new --json and edit --json return the same object details --json does, so a script can create a command and use its slug immediately without a second lookup. As everywhere else in Command Book, environment variable values are never printed back — only their names.
• Scriptable exit codes for the new paths. A name collision on new exits 45 (silence it with --if-not-exists), refusing to delete a running command exits 46, and refusing to start a duplicate exits 47, joining the existing HTTP-flavored codes so scripts can branch on outcomes instead of scraping text. Exit 47 in particular means "already up" rather than "something went wrong" — a script or agent can treat it as success and carry on.
• The Claude Code integration was rewritten around all of this. The bundled skill and commandbook operator agent previously told AI agents outright that new and edit "cannot be driven headlessly," steering them toward ad-hoc runs for everything. They now document the full flag surface and draw the useful distinction instead: run it ad-hoc when it's throwaway, save it when you'll want it tomorrow. If you have the integration installed, it updates itself the next time Command Book launches.

Bug Fixes

• stop could report success while your process was still running. It treated the death of the process as proof that it had stopped — but that's exactly what an auto-restarting command looks like in the moment before it comes back. So stop would print Stopped API Server (pid 71688), exit cleanly, and leave something running. It now waits for confirmation that the thing supervising your command has actually let go, and escalates if it hasn't. stop will no longer tell you a command is stopped while anything for it is still alive.
• kill on a running command restarted it instead of stopping it. If you sent SIGTERM to a commandbook run (which is what a plain kill does, and what most process managers and shutdown scripts send), Command Book passed the signal to your process, watched it die, decided it had crashed, and dutifully started it again. SIGTERM is now treated as a deliberate stop, the same as Ctrl+C.
• A command could be supervised with no record of it anywhere. If two Command Book processes started at the same moment on a machine that had never run one before, they could collide while setting up their shared bookkeeping — and the one that lost ran your command completely untracked. status couldn't see it and stop couldn't reach it, with nothing but a stray database complaint to hint at why. That setup is now retried, and in the genuinely unrecoverable case run tells you plainly that the run won't be visible to status or stop, rather than pretending everything is fine.
• A command started by certain tools could ignore kill entirely. Some launchers — CI runners, launchd, and a few AI agent runtimes — hand their child processes a configuration that suppresses signals, and Command Book was inheriting it. A command started that way could never be stopped with kill. It now insists on being able to hear the signals it handles.
• The CLI's database schema had drifted a version behind the app. The command-line tool carried its own copy of the database setup, and it had fallen one migration short of the app's — missing the column that stores custom command icons. It never caused visible trouble, because the CLI had no reason to write that column, but on a machine where the CLI ran before the app was ever opened it would have created a slightly out-of-date database. Both copies are back in lockstep, with a test that fails the build if they ever drift again.

Command Book v1.0.52

Released June 29, 2026

What's New

The Claude Code integration is now a skill and an operator agent

The Command Book integration for Claude Code grew up. Instead of a single flat skill, installing it now sets up a proper bundle: the lean ask-commandbook skill that teaches Claude the launch → wait → stop loop right in your main conversation, plus a dedicated commandbook operator agent that takes over when you're orchestrating several long-running processes at once. Install it the same way as before — Settings → AI Agents → "Install Claude Code Skill & Agent" or the matching File menu item — and that's it. If you already had the old skill installed, Command Book quietly migrates you to the new bundle the next time it launches and cleans up the legacy folder, so there's nothing to uninstall by hand.

Your installed integration keeps itself up to date

Once installed, the bundle stays current on its own. Each time Command Book launches it checks what you have in ~/.claude/ and, whenever the app ships a newer version, refreshes the skill and agent in place — so Claude always works from the latest guidance without you reinstalling anything. Installs from 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 copy is genuinely newer, and it never delays startup.

Improvements

• A much more accurate CLI reference: The command reference bundled for your AI agent was rewritten and verified line-by-line against the shipping CLI. It now covers commandbook details, ad-hoc run --command, the real --json output shapes for status, wait, stop, and details, full exit-code tables, and exactly how run executes your command — so Claude gets the details right instead of guessing.

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