Files
02a2b568d4 fix(examples): keep the macos launchagent running when reinstall is declined (#4734)
## Description

In `examples/deployment/macos-launchagent/install.sh` (lines 96-113 on
`1da8930a`), when the plist already exists the script runs `launchctl
bootout` on the running service first and only then asks `Reinstall?
[y/N]`. Answering `N` prints `Installation cancelled.` and exits 0, but
the service is already stopped, so a cancelled install leaves the proxy
down until the next login or a manual `launchctl bootstrap`.

This PR moves the stop block below the prompt, unchanged, so `bootout`
runs only after the user confirmed, or in `--unattended` mode (which
never prompts). Nothing else changes.

Part of #4730

## Type of Change

- [x] Bug fix (non-breaking change that fixes an issue)
- [ ] New feature (non-breaking change that adds functionality)
- [ ] Breaking change (fix or feature that would cause existing
functionality to change)
- [ ] Documentation update
- [ ] Performance improvement
- [ ] Code refactoring (no functional changes)

## Changes Made

- `examples/deployment/macos-launchagent/install.sh`: the `launchctl
print` / `launchctl bootout` block moves from before the `Reinstall?`
prompt to after it, with a one-line comment. 6 lines moved, 1 comment
added.

## Testing

- [x] Unit tests pass (`pytest`) (the new test file only; I did not run
the full suite)
- [ ] Linting passes (`ruff check .`)
- [ ] Type checking passes (`mypy headroom`)
- [x] New tests added for new functionality
- [x] Manual testing performed

This is a shell example script, so the Python lint and type checks do
not apply to it. The new test file is checked with ruff (below). The
project's bug-fix policy asks for a test that fails before and passes
after, so a committed test runs the real script against stubs (below),
and the earlier manual driver is kept under it.

### Test Output

#### Committed regression test

`tests/test_macos_launchagent_install_cancel.py` runs the real
`install.sh` under `bash` with stub `uname`, `launchctl`, `headroom` and
`lsof` on `PATH` and a fake `HOME`. It is skipped when `bash` is not on
`PATH`. Environment: Ubuntu on WSL2, bash, Python venv
`/var/tmp/cb-fix-8mh5/repo/.venv`, pytest `-p no:cacheprovider`, test
file run from a scratch copy (no `headroom` import, no repo conftest).

Same test file, `install.sh` taken from `origin/main` (`1da8930a`):

```text
FAILED test_declining_reinstall_keeps_the_service_running
1 failed, 1 passed in 0.14s
(test_confirming_reinstall_stops_the_service passes: bootout is still called after y)
```

Same test file, `install.sh` from this branch:

```text
2 passed in 0.06s
```

`ruff format --check` and `ruff check` on the new file: clean.

#### Earlier manual driver

Driver: copies `install.sh` and the plist template into a scratch
directory, puts stubs first on `PATH` (`uname` prints `Darwin`;
`headroom` exits 0; `lsof` exits 1; `launchctl` appends each call to a
log and exits 0, so `launchctl print` reports a running service), points
`HOME` at a fake home that already contains
`Library/LaunchAgents/com.headroom.proxy.plist`, and feeds stdin. Git
Bash on Windows 11. Paths shortened to `<run>`; output filtered to the
lines that matter.

`origin/main` (`1da8930a`), `echo N | bash install.sh`:

```text
⚠ LaunchAgent already installed at: <run>/fakehome/Library/LaunchAgents/com.headroom.proxy.plist
==> Stopping existing service...
Installation cancelled.
rc=0
--- launchctl call log:
launchctl print gui/197609/com.headroom.proxy
launchctl bootout gui/197609/com.headroom.proxy
```

This branch, `echo N | bash install.sh`:

```text
⚠ LaunchAgent already installed at: <run>/fakehome/Library/LaunchAgents/com.headroom.proxy.plist
Installation cancelled.
rc=0
--- launchctl call log:
(no calls)
```

This branch, `printf 'y\n\n' | bash install.sh` (answer `y`, then the
default port). Reinstall still boots out and bootstraps; `origin/main`
produces the same four calls:

```text
⚠ LaunchAgent already installed at: <run>/fakehome/Library/LaunchAgents/com.headroom.proxy.plist
==> Stopping existing service...
✓ Created: <run>/fakehome/Library/LaunchAgents/com.headroom.proxy.plist
✓ LaunchAgent loaded successfully
✓ Service is running
⚠ Service is running but port 8787 is not listening yet
✓ Headroom proxy installed successfully!
rc=0
--- launchctl call log:
launchctl print gui/197609/com.headroom.proxy
launchctl bootout gui/197609/com.headroom.proxy
launchctl bootstrap gui/197609 <run>/fakehome/Library/LaunchAgents/com.headroom.proxy.plist
launchctl print gui/197609/com.headroom.proxy
```

(The "port 8787 is not listening" warning comes from the `lsof` stub
exiting 1; it is not a finding.)

## Real Behavior Proof

- Environment: Git Bash on Windows 11 with stubbed `uname`, `launchctl`,
`headroom`, `lsof`; no macOS, no real LaunchAgent.
- Exact command / steps: the driver above, `echo N | bash install.sh` on
`origin/main`'s script and on this branch's, then `printf 'y\n\n' | bash
install.sh` on both.
- Observed result: on `origin/main`, answering `N` made the stub log
`launchctl bootout` before `Installation cancelled.`; on this branch the
log is empty. Answering `y` makes the same four `launchctl` calls on
both.
- Not tested: real macOS launchd (the proof uses stubs on Windows and
WSL, not a live LaunchAgent); real `launchctl` on macOS; the
`--unattended` path (the block there runs unchanged, only its place in
the file differs, but I did not run it).

## Runtime Rollout Safety

- Rollout-managed feature(s): none; example script only.
- Minimum rollout channel: n/a
- Stable/default behavior changed: only the cancel path: the running
service is no longer stopped when the user declines.
- Kill switch / disable path: n/a
- Unsafe override required: no
- Qualification impact: none
- Rollback path: revert this commit.

## Review Readiness

- [x] I have performed a self-review
- [x] This PR is ready for human review

## Checklist

- [x] My code follows the project's style guidelines
- [x] I have performed a self-review of my code
- [x] I have commented my code, particularly in hard-to-understand areas
- [ ] I have made corresponding changes to the documentation
- [x] My changes generate no new warnings
- [x] I have added tests that prove my fix is effective or that my
feature works
- [x] New and existing unit tests pass locally with my changes (new test
file only; the stubbed runs above are the check)
- [x] I did **not** edit `CHANGELOG.md` — it is generated by
release-please from my Conventional Commit PR title (a CI guard enforces
this)

## Additional Notes

- Scope is an example script; the effect of the bug is a stopped proxy
on the user's own machine.
- Other defects in the same directory are in #4730 and separate PRs.

Produced with AI assistance (Claude Code) operated by me (HetCreep); the
driver was run on my machine against a clone of the repository.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
Co-authored-by: JD Davis <mxjerrett@gmail.com>
2026-11-11 09:57:40 -06:00

228 lines
6.3 KiB
Bash
Executable File

#!/usr/bin/env bash
#
# Headroom Proxy LaunchAgent Installer for macOS
#
# This script installs the headroom proxy as a macOS LaunchAgent for automatic
# startup and management. The service will start on login and restart on crash.
#
# Usage: ./install.sh [--port PORT] [--unattended]
#
# Options:
# --port PORT Port for proxy server (default: 8787)
# --unattended Skip interactive prompts (use defaults)
#
set -euo pipefail
# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# Configuration
PLIST_LABEL="com.headroom.proxy"
PLIST_FILENAME="${PLIST_LABEL}.plist"
PLIST_DEST="${HOME}/Library/LaunchAgents/${PLIST_FILENAME}"
LOG_DIR="${HOME}/Library/Logs/headroom"
DEFAULT_PORT=8787
USER_UID=$(id -u)
# Parse command line arguments
CUSTOM_PORT=""
UNATTENDED=false
while [[ $# -gt 0 ]]; do
case $1 in
--port)
CUSTOM_PORT="$2"
shift 2
;;
--unattended)
UNATTENDED=true
shift
;;
*)
echo "Unknown option: $1"
echo "Usage: $0 [--port PORT] [--unattended]"
exit 1
;;
esac
done
# Helper functions
info() {
echo -e "${BLUE}==>${NC} $*"
}
success() {
echo -e "${GREEN}✓${NC} $*"
}
warning() {
echo -e "${YELLOW}⚠${NC} $*"
}
error() {
echo -e "${RED}✗${NC} $*" >&2
}
fatal() {
error "$*"
exit 1
}
# Check if we're on macOS
OS_NAME=$(uname -s)
if [[ "${OS_NAME}" != "Darwin" ]]; then
fatal "This script is only for macOS. Use systemd on Linux."
fi
# Check if headroom is installed
info "Checking for headroom installation..."
HEADROOM_PATH=$(command -v headroom || true)
if [[ -z "${HEADROOM_PATH}" ]]; then
fatal "headroom not found in PATH. Please install it first: pip install headroom-ai[proxy]"
fi
success "Found headroom at: ${HEADROOM_PATH}"
# Verify proxy support
info "Verifying proxy support..."
if ! "${HEADROOM_PATH}" proxy --help >/dev/null 2>&1; then
fatal "headroom proxy command not available. Install with: pip install headroom-ai[proxy]"
fi
success "Proxy support verified"
# Check if service is already installed
if [[ -f "${PLIST_DEST}" ]]; then
warning "LaunchAgent already installed at: ${PLIST_DEST}"
if [[ "${UNATTENDED}" == false ]]; then
read -rp "Reinstall? [y/N] " response
if [[ ! "${response}" =~ ^[Yy]$ ]]; then
echo "Installation cancelled."
exit 0
fi
fi
# Stop the service only after the user confirmed (or in unattended mode)
if launchctl print "gui/${USER_UID}/${PLIST_LABEL}" >/dev/null 2>&1; then
info "Stopping existing service..."
launchctl bootout "gui/${USER_UID}/${PLIST_LABEL}" 2>/dev/null || true
fi
fi
# Get port configuration
if [[ -n "${CUSTOM_PORT}" ]]; then
PORT="${CUSTOM_PORT}"
elif [[ "${UNATTENDED}" == true ]]; then
PORT="${DEFAULT_PORT}"
else
read -rp "Port for proxy server (default: ${DEFAULT_PORT}): " PORT
PORT="${PORT:-${DEFAULT_PORT}}"
fi
# Validate port number
if ! [[ "${PORT}" =~ ^[1-9][0-9]{3,4}$ ]] || [[ "${PORT}" -lt 1024 ]] || [[ "${PORT}" -gt 65535 ]]; then
fatal "Invalid port number: ${PORT} (must be 1024-65535)"
fi
# Check if port is in use
if lsof -iTCP:"${PORT}" -sTCP:LISTEN -t >/dev/null 2>&1; then
warning "Port ${PORT} is already in use"
if [[ "${UNATTENDED}" == false ]]; then
read -rp "Continue anyway? [y/N] " response
if [[ ! "${response}" =~ ^[Yy]$ ]]; then
echo "Installation cancelled."
exit 0
fi
fi
fi
# Create log directory
info "Creating log directory..."
mkdir -p "${LOG_DIR}"
success "Log directory: ${LOG_DIR}"
# Find template file
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
TEMPLATE_FILE="${SCRIPT_DIR}/${PLIST_FILENAME}.template"
if [[ ! -f "${TEMPLATE_FILE}" ]]; then
fatal "Template file not found: ${TEMPLATE_FILE}"
fi
# Generate plist from template
info "Generating LaunchAgent plist..."
sed -e "s|__HEADROOM_PATH__|${HEADROOM_PATH}|g" \
-e "s|__PORT__|${PORT}|g" \
-e "s|__HOME__|${HOME}|g" \
"${TEMPLATE_FILE}" >"${PLIST_DEST}"
success "Created: ${PLIST_DEST}"
# Set correct permissions
chmod 644 "${PLIST_DEST}"
# Load the LaunchAgent
info "Loading LaunchAgent..."
if launchctl bootstrap "gui/${USER_UID}" "${PLIST_DEST}" 2>/dev/null; then
success "LaunchAgent loaded successfully"
else
# If bootstrap fails, try to bootout first in case it was already loaded
launchctl bootout "gui/${USER_UID}/${PLIST_LABEL}" 2>/dev/null || true
if launchctl bootstrap "gui/${USER_UID}" "${PLIST_DEST}"; then
success "LaunchAgent loaded successfully"
else
fatal "Failed to load LaunchAgent. Check logs at: ${LOG_DIR}"
fi
fi
# Wait a moment for service to start
sleep 2
# Verify the service is running
info "Verifying service status..."
if launchctl print "gui/${USER_UID}/${PLIST_LABEL}" >/dev/null 2>&1; then
success "Service is running"
# Check if port is listening
if lsof -iTCP:"${PORT}" -sTCP:LISTEN -t >/dev/null 2>&1; then
success "Port ${PORT} is listening"
else
warning "Service is running but port ${PORT} is not listening yet"
warning "Check logs: tail -f ${LOG_DIR}/proxy-error.log"
fi
else
fatal "Service failed to start. Check logs at: ${LOG_DIR}"
fi
# Display success message
echo ""
echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}✓ Headroom proxy installed successfully!${NC}"
echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
echo "Service details:"
echo " • Port: ${PORT}"
echo " • Logs: ${LOG_DIR}"
echo " • Label: ${PLIST_LABEL}"
echo ""
echo "Shell integration:"
echo " Add to ~/.bashrc or ~/.zshrc:"
echo ""
echo " export HEADROOM_PROXY_PORT=${PORT}"
echo " source <path-to>/shell-integration.sh"
echo ""
echo " Or manually set:"
echo ""
echo " export ANTHROPIC_BASE_URL=http://localhost:${PORT}"
echo ""
echo "Useful commands:"
echo " • Check status: launchctl print gui/\${USER_UID}/${PLIST_LABEL}"
echo " • View logs: tail -f ${LOG_DIR}/proxy.log"
echo " • View errors: tail -f ${LOG_DIR}/proxy-error.log"
echo " • Restart: launchctl kickstart -k gui/\${USER_UID}/${PLIST_LABEL}"
echo " • Uninstall: ./uninstall.sh"
echo ""