agent-cli 0.95.8__tar.gz → 0.95.10__tar.gz

agent_cli-0.95.10/.github/scripts/update_cask.py

@@ -0,0 +1,87 @@
+"""Update the Agent CLI Homebrew cask version and checksum."""
+
+from __future__ import annotations
+
+import argparse
+import re
+from pathlib import Path
+
+VERSION_RE = re.compile(r'^(?P<indent>\s*)version "[^"]+"$')
+SHA256_RE = re.compile(r'^(?P<indent>\s*)sha256 "[0-9a-f]{64}"$')
+
+
+def _validate_sha256(value: str) -> str:
+    if not re.fullmatch(r"[0-9a-f]{64}", value):
+        msg = "sha256 must be 64 lowercase hexadecimal characters"
+        raise ValueError(msg)
+    return value
+
+
+def _validate_version(value: str) -> str:
+    value = value.removeprefix("v")
+    if not re.fullmatch(r"\d+(?:\.\d+)*(?:[-,._A-Za-z0-9]+)?", value):
+        msg = f"unsupported cask version: {value}"
+        raise ValueError(msg)
+    return value
+
+
+def update_cask_text(text: str, *, version: str, sha256: str) -> str:
+    """Replace the single version and sha256 stanzas in a cask."""
+    version = _validate_version(version)
+    sha256 = _validate_sha256(sha256)
+
+    version_count = 0
+    sha256_count = 0
+    lines: list[str] = []
+    for source_line in text.splitlines(keepends=True):
+        newline = "\n" if source_line.endswith("\n") else ""
+        content = source_line.removesuffix("\n")
+
+        if match := VERSION_RE.match(content):
+            output_line = f'{match.group("indent")}version "{version}"{newline}'
+            version_count += 1
+        elif match := SHA256_RE.match(content):
+            output_line = f'{match.group("indent")}sha256 "{sha256}"{newline}'
+            sha256_count += 1
+        else:
+            output_line = source_line
+        lines.append(output_line)
+
+    if version_count != 1:
+        msg = f"expected exactly one version stanza, found {version_count}"
+        raise ValueError(msg)
+    if sha256_count != 1:
+        msg = f"expected exactly one sha256 stanza, found {sha256_count}"
+        raise ValueError(msg)
+
+    return "".join(lines)
+
+
+def update_cask_file(path: Path, *, version: str, sha256: str) -> None:
+    """Update a cask file in place."""
+    path.write_text(
+        update_cask_text(path.read_text(), version=version, sha256=sha256),
+        encoding="utf-8",
+    )
+
+
+def main() -> None:
+    """Run the command-line cask updater."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--cask",
+        type=Path,
+        default=Path("Casks/agent-cli.rb"),
+        help="Path to the cask file to update.",
+    )
+    parser.add_argument(
+        "--version", required=True, help="Release version, with or without v prefix."
+    )
+    parser.add_argument("--sha256", required=True, help="SHA-256 checksum for the release DMG.")
+    args = parser.parse_args()
+
+    update_cask_file(args.cask, version=args.version, sha256=args.sha256)
+
+
+if __name__ == "__main__":
+    main()

agent_cli-0.95.10/.github/workflows/release.yml

@@ -0,0 +1,133 @@
+name: Publish Release
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  deploy:
+    name: Publish Python package
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/${{ github.repository }}
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v6
+      - name: Install uv
+        uses: astral-sh/setup-uv@v8.1.0
+      - name: Build
+        run: uv build
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+  build_macos_app:
+    name: Build and publish macOS app
+    runs-on: macos-latest
+    timeout-minutes: 45
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v6
+      - name: Install uv
+        uses: astral-sh/setup-uv@v8.1.0
+      - name: Import Developer ID certificate
+        uses: apple-actions/import-codesign-certs@v7
+        with:
+          p12-file-base64: ${{ secrets.MACOS_CODESIGN_CERTIFICATE_BASE64 }}
+          p12-password: ${{ secrets.MACOS_CODESIGN_CERTIFICATE_PASSWORD }}
+          keychain-password: ${{ secrets.MACOS_KEYCHAIN_PASSWORD }}
+      - name: Resolve Developer ID identity
+        id: codesign
+        run: |
+          IDENTITY=$(
+            security find-identity -v -p codesigning |
+              awk -F '"' '/Developer ID Application/ { print $2; exit }'
+          )
+          if [[ -z "$IDENTITY" ]]; then
+            echo "Developer ID Application signing identity not found." >&2
+            exit 1
+          fi
+          echo "identity=$IDENTITY" >> "$GITHUB_OUTPUT"
+      - name: Build notarized macOS DMG
+        env:
+          CODESIGN_IDENTITY: ${{ steps.codesign.outputs.identity }}
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_APP_SPECIFIC_PASSWORD: ${{ secrets.APPLE_APP_SPECIFIC_PASSWORD }}
+          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+          APP_VERSION: ${{ github.event.release.tag_name }}
+          BUILD_VERSION: ${{ github.run_number }}
+          SPARKLE_PUBLIC_ED_KEY: ${{ vars.SPARKLE_PUBLIC_ED_KEY }}
+        run: |
+          if [[ -z "$SPARKLE_PUBLIC_ED_KEY" ]]; then
+            echo "SPARKLE_PUBLIC_ED_KEY repository variable is required to enable Sparkle updates." >&2
+            exit 1
+          fi
+          NOTARIZE=1 macos/build-macos-app.sh --dmg
+          ditto -c -k --keepParent dist/macos/AgentCLI.app dist/macos/AgentCLI.zip
+      - name: Upload macOS app to GitHub Release
+        env:
+          GH_TOKEN: ${{ github.token }}
+          TAG_NAME: ${{ github.event.release.tag_name }}
+        run: gh release upload "$TAG_NAME" dist/macos/AgentCLI.dmg dist/macos/AgentCLI.zip --clobber
+      - name: Update Sparkle appcast
+        env:
+          GH_TOKEN: ${{ github.token }}
+          TAG_NAME: ${{ github.event.release.tag_name }}
+          SPARKLE_PRIVATE_ED_KEY: ${{ secrets.SPARKLE_PRIVATE_ED_KEY }}
+        run: |
+          git fetch origin main
+          git switch --force-create release-metadata origin/main
+
+          if [[ -z "$SPARKLE_PRIVATE_ED_KEY" ]]; then
+            echo "SPARKLE_PRIVATE_ED_KEY is required to sign Sparkle updates." >&2
+            exit 1
+          fi
+
+          SPARKLE_GENERATE_APPCAST="macos/AgentCLI/.build/artifacts/sparkle/Sparkle/bin/generate_appcast"
+          if [[ ! -x "$SPARKLE_GENERATE_APPCAST" ]]; then
+            echo "Sparkle generate_appcast not found: $SPARKLE_GENERATE_APPCAST" >&2
+            exit 1
+          fi
+
+          APPCAST_DIR="$RUNNER_TEMP/agentcli-appcast"
+          rm -rf "$APPCAST_DIR"
+          mkdir -p "$APPCAST_DIR"
+          cp dist/macos/AgentCLI.zip "$APPCAST_DIR/AgentCLI.zip"
+          cp macos/appcast.xml "$APPCAST_DIR/appcast.xml"
+          gh release view "$TAG_NAME" --json body --jq .body >"$APPCAST_DIR/AgentCLI.md"
+
+          printf '%s' "$SPARKLE_PRIVATE_ED_KEY" |
+            "$SPARKLE_GENERATE_APPCAST" \
+              --ed-key-file - \
+              --download-url-prefix "https://github.com/basnijholt/agent-cli/releases/download/${TAG_NAME}/" \
+              --link "https://github.com/basnijholt/agent-cli" \
+              --embed-release-notes \
+              --maximum-versions 10 \
+              -o "$APPCAST_DIR/appcast.xml" \
+              "$APPCAST_DIR"
+
+          cp "$APPCAST_DIR/appcast.xml" macos/appcast.xml
+      - name: Update Homebrew cask and Sparkle appcast
+        env:
+          TAG_NAME: ${{ github.event.release.tag_name }}
+        run: |
+          VERSION="${TAG_NAME#v}"
+          SHA256=$(shasum -a 256 dist/macos/AgentCLI.dmg | awk '{ print $1 }')
+
+          python3 .github/scripts/update_cask.py \
+            --version "$VERSION" \
+            --sha256 "$SHA256"
+
+          if git diff --quiet -- Casks/agent-cli.rb macos/appcast.xml; then
+            echo "Casks/agent-cli.rb and macos/appcast.xml are already up to date."
+            exit 0
+          fi
+
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add Casks/agent-cli.rb macos/appcast.xml
+          git commit -m "Update AgentCLI release metadata to ${TAG_NAME}"
+          git pull --rebase origin main
+          git push origin HEAD:main

{agent_cli-0.95.8 → agent_cli-0.95.10}/Casks/agent-cli.rb

@@ -1,6 +1,6 @@
 cask "agent-cli" do
-  version "0.95.7"
-  sha256 "9db4a8d9f44765e1197d687a46e4cde041ada2d5284e6a22324c706d2a40848e"
+  version "0.95.9"
+  sha256 "b2d7dd26b67fceb32db31d5506c0890f9c879f56d049e6fd051fac151b68a300"
 
   url "https://github.com/basnijholt/agent-cli/releases/download/v#{version}/AgentCLI.dmg"
   name "Agent CLI"

{agent_cli-0.95.8 → agent_cli-0.95.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-cli
-Version: 0.95.8
+Version: 0.95.10
 Summary: A suite of AI-powered command-line tools for text correction, audio transcription, and voice assistance.
 Project-URL: Homepage, https://github.com/basnijholt/agent-cli
 Author-email: Bas Nijholt <bas@nijho.lt>

{agent_cli-0.95.8 → agent_cli-0.95.10}/agent_cli/daemon/cli.py

@@ -7,6 +7,7 @@ Manage agent-cli servers as background daemons:
 
 from __future__ import annotations
 
+import json
 import platform
 from typing import Annotated
 
@@ -17,6 +18,7 @@ from agent_cli.cli import app as main_app
 from agent_cli.core.utils import console, err_console
 from agent_cli.install.service_config import (
     SERVICES,
+    ServiceStatus,
     get_default_services,
     get_service_manager,
 )
@@ -42,6 +44,9 @@ Install, uninstall, and monitor agent-cli servers running as system daemons
 **Examples:**
 
 ```bash
+# Ensure whisper is installed and running
+agent-cli daemon ensure whisper
+
 # Install whisper as a background daemon
 agent-cli daemon install whisper
 
@@ -196,6 +201,110 @@ def _ensure_uv_installed(no_confirm: bool) -> None:
         raise typer.Exit(1)
 
 
+def _service_status_payload(
+    *,
+    service: str,
+    action: str,
+    status: ServiceStatus,
+    message: str,
+) -> dict[str, object]:
+    installed = bool(status.installed)
+    running = bool(status.running)
+    return {
+        "service": service,
+        "action": action,
+        "installed": installed,
+        "running": running,
+        "pid": getattr(status, "pid", None) if running else None,
+        "message": message,
+    }
+
+
+@app.command("ensure")
+def ensure_cmd(
+    service: Annotated[
+        str,
+        typer.Argument(help="Service to ensure is installed and running"),
+    ],
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Output machine-readable status as JSON"),
+    ] = False,
+    quiet: Annotated[
+        bool,
+        typer.Option("--quiet", "-q", help="Suppress normal success output"),
+    ] = False,
+) -> None:
+    """Ensure one daemon is installed and running.
+
+    This is intended for app integrations that need a single repair command
+    instead of parsing human-oriented `daemon status` output.
+    """
+    if service not in SERVICES:
+        err_console.print(
+            f"[bold red]Error:[/bold red] Unknown service '{service}'. "
+            f"Available: {', '.join(SERVICES.keys())}",
+        )
+        raise typer.Exit(1)
+
+    try:
+        manager = get_service_manager()
+    except RuntimeError as e:
+        err_console.print(f"[bold red]Error:[/bold red] {e}")
+        raise typer.Exit(1) from None
+
+    status = manager.get_service_status(service)
+    if status.installed and status.running:
+        payload = _service_status_payload(
+            service=service,
+            action="already_running",
+            status=status,
+            message="Already running",
+        )
+    else:
+        action = "installed" if not status.installed else "restarted"
+        result = manager.install_service(service)
+        if not result.success:
+            payload = _service_status_payload(
+                service=service,
+                action="failed",
+                status=status,
+                message=result.message,
+            )
+            if json_output:
+                console.print(json.dumps(payload))
+            else:
+                err_console.print(f"[bold red]Error:[/bold red] {service}: {result.message}")
+            raise typer.Exit(1)
+
+        status = manager.get_service_status(service)
+        if not status.installed or not status.running:
+            message = f"{result.message}, but service is not running"
+            payload = _service_status_payload(
+                service=service,
+                action="failed",
+                status=status,
+                message=message,
+            )
+            if json_output:
+                console.print(json.dumps(payload))
+            else:
+                err_console.print(f"[bold red]Error:[/bold red] {service}: {message}")
+            raise typer.Exit(1)
+
+        payload = _service_status_payload(
+            service=service,
+            action=action,
+            status=status,
+            message=result.message,
+        )
+
+    if json_output:
+        console.print(json.dumps(payload))
+    elif not quiet:
+        console.print(f"{service}: {payload['message']}")
+
+
 @app.command("install")
 def install_cmd(  # noqa: PLR0912, PLR0915
     services: Annotated[

{agent_cli-0.95.8 → agent_cli-0.95.10}/docs/commands/daemon.md

@@ -147,6 +147,9 @@ agent-cli daemon uninstall whisper
  Examples:
 
 
+  # Ensure whisper is installed and running
+  agent-cli daemon ensure whisper
+
   # Install whisper as a background daemon
   agent-cli daemon install whisper
 
@@ -167,6 +170,7 @@ agent-cli daemon uninstall whisper
 ╰────────────────────────────────────────────────────────────────────────────────────────╯
 ╭─ Commands ─────────────────────────────────────────────────────────────────────────────╮
 │ status      Check status of installed daemons.                                         │
+│ ensure      Ensure one daemon is installed and running.                                │
 │ install     Install server daemons as background processes.                            │
 │ uninstall   Uninstall server daemons.                                                  │
 ╰────────────────────────────────────────────────────────────────────────────────────────╯

{agent_cli-0.95.8 → agent_cli-0.95.10}/macos/AgentCLI/Package.resolved

@@ -8,6 +8,15 @@
         "revision" : "70caa8dea43e2d273cd5ab78885d7eff01df550c",
         "version" : "1.10.0"
       }
+    },
+    {
+      "identity" : "sparkle",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/sparkle-project/Sparkle",
+      "state" : {
+        "revision" : "6276ba2b404829d139c45ff98427cf90e2efc59b",
+        "version" : "2.9.2"
+      }
     }
   ],
   "version" : 2

{agent_cli-0.95.8 → agent_cli-0.95.10}/macos/AgentCLI/Package.swift

@@ -12,12 +12,14 @@ let package = Package(
     ],
     dependencies: [
         .package(url: "https://github.com/sindresorhus/KeyboardShortcuts", exact: "1.10.0"),
+        .package(url: "https://github.com/sparkle-project/Sparkle", exact: "2.9.2"),
     ],
     targets: [
         .executableTarget(
             name: "AgentCLI",
             dependencies: [
                 .product(name: "KeyboardShortcuts", package: "KeyboardShortcuts"),
+                .product(name: "Sparkle", package: "Sparkle"),
             ],
             path: "Sources/AgentCLI"
         ),

{agent_cli-0.95.8 → agent_cli-0.95.10}/macos/AgentCLI/README.md

@@ -30,6 +30,12 @@ clipboard utility shortcuts still use `KeyboardShortcuts` global handlers. The
 login option uses Apple's login item API for the main app bundle, so macOS may
 require approval in System Settings → General → Login Items.
 
+The app uses Sparkle for direct app updates. Release builds stamp
+`SUPublicEDKey` into `Info.plist`, publish signed updates in `macos/appcast.xml`,
+upload `AgentCLI.zip` for Sparkle, and expose **Check for Updates...** from the
+menu bar and Settings. Local builds without a Sparkle public key still run, but
+update checks are disabled.
+
 ## Build
 
 From the repository root:
@@ -86,6 +92,7 @@ NOTARIZE=1 \
 APPLE_ID="you@example.com" \
 APPLE_APP_SPECIFIC_PASSWORD="xxxx-xxxx-xxxx-xxxx" \
 APPLE_TEAM_ID="TEAMID" \
+SPARKLE_PUBLIC_ED_KEY="public-ed25519-key" \
 ./macos/build-macos-app.sh --dmg
 ```
 
@@ -103,3 +110,8 @@ workflow expects these repository secrets:
 - `APPLE_ID`: Apple ID email for notarization
 - `APPLE_APP_SPECIFIC_PASSWORD`: app-specific password for `notarytool`
 - `APPLE_TEAM_ID`: Apple Developer Team ID
+- `SPARKLE_PRIVATE_ED_KEY`: private Sparkle EdDSA key for signing updates
+
+The workflow also expects the repository variable `SPARKLE_PUBLIC_ED_KEY`.
+Generate the key pair with Sparkle's `generate_keys` tool and store only the
+private key as a GitHub secret.

{agent_cli-0.95.8 → agent_cli-0.95.10}/macos/AgentCLI/Resources/Info.plist

@@ -28,5 +28,9 @@
 	<true/>
 	<key>NSMicrophoneUsageDescription</key>
 	<string>Agent CLI uses microphone access when you start transcription or voice editing from the menu bar.</string>
+	<key>SUEnableInstallerLauncherService</key>
+	<true/>
+	<key>SUFeedURL</key>
+	<string>https://raw.githubusercontent.com/basnijholt/agent-cli/main/macos/appcast.xml</string>
 </dict>
 </plist>

{agent_cli-0.95.8 → agent_cli-0.95.10}/macos/AgentCLI/Sources/AgentCLI/AgentCLIApp.swift

@@ -6,6 +6,7 @@ struct AgentCLIApp: App {
     @NSApplicationDelegateAdaptor(AppDelegate.self) private var appDelegate
     @Environment(\.openWindow) private var openWindow
     @StateObject private var runner = AgentCommandRunner.shared
+    @StateObject private var appUpdater = AppUpdater.shared
     @StateObject private var loginItemController = LoginItemController.shared
     @StateObject private var shortcutSummary = ShortcutSummaryState.shared
     @AppStorage(RuntimeSettings.useUserInstalledAgentCLIKey)
@@ -33,8 +34,7 @@ struct AgentCLIApp: App {
 
             Divider()
 
-            Text("Voice: \(runner.menuStatusMessage)")
-                .lineLimit(1)
+            VoiceStatusMenuItem(runner: runner)
 
             Text(shortcutSummary.summary)
                 .lineLimit(1)
@@ -77,6 +77,13 @@ struct AgentCLIApp: App {
                 Label("Settings...", systemImage: "gearshape")
             }
 
+            Button {
+                appUpdater.checkForUpdates()
+            } label: {
+                Label("Check for Updates...", systemImage: "arrow.down.circle")
+            }
+            .disabled(!appUpdater.canCheckForUpdates)
+
             Menu {
                 Button {
                     runner.run(.voiceServiceStatus)

{agent_cli-0.95.8 → agent_cli-0.95.10}/macos/AgentCLI/Sources/AgentCLI/AgentCommandRunner.swift

@@ -29,8 +29,8 @@ final class AgentCommandRunner: ObservableObject {
     @Published private(set) var isRecording = false
     @Published private(set) var bootstrapPhase: BootstrapPhase = .idle
     @Published private var activeCommandCount = 0
-    @Published private var bootstrapAnimationTick = 0
-    @Published private var bootstrapElapsedSeconds = 0
+    private var bootstrapAnimationTick = 0
+    private var bootstrapElapsedSeconds = 0
     private var recordingIndicator = RecordingIndicatorController()
     private let pasteController: TranscriptPasteController
     private let bootstrap: AgentBootstrap
@@ -161,7 +161,7 @@ final class AgentCommandRunner: ObservableObject {
                     self.stopBootstrapAnimationTimer()
                     return
                 }
-                self.bootstrapAnimationTick = (self.bootstrapAnimationTick + 1) % 3
+                self.bootstrapAnimationTick = (self.bootstrapAnimationTick + 1) % 4
                 if let startedAt = self.bootstrapPhaseStartedAt {
                     self.bootstrapElapsedSeconds = max(0, Int(Date().timeIntervalSince(startedAt)))
                 }

{agent_cli-0.95.8 → agent_cli-0.95.10}/macos/AgentCLI/Sources/AgentCLI/AgentRuntime.swift

@@ -12,6 +12,9 @@ private enum AgentCLIRuntimeMode: Equatable {
     }
 }
 
+typealias AgentProcessRunner = (URL, [String], [String: String]) -> CommandResult
+typealias LocalhostConnector = (UInt16) -> Bool
+
 struct AgentRuntime {
     static let shared = AgentRuntime()
 
@@ -37,6 +40,9 @@ struct AgentRuntime {
     private let fileManager = FileManager.default
     private let baseEnvironment: [String: String]
     private let userDefaults: UserDefaults
+    private let processRunner: AgentProcessRunner
+    private let localhostConnector: LocalhostConnector
+    private let whisperReadyTimeout: TimeInterval
     let appSupportURL: URL
     let bundledUVURL: URL
     let bundledWheelsURL: URL
@@ -56,10 +62,18 @@ struct AgentRuntime {
     init(
         environment: [String: String] = ProcessInfo.processInfo.environment,
         bundle: Bundle = .main,
-        userDefaults: UserDefaults = .standard
+        userDefaults: UserDefaults = .standard,
+        processRunner: @escaping AgentProcessRunner = {
+            AgentRuntime.runProcess(executableURL: $0, arguments: $1, environment: $2)
+        },
+        localhostConnector: @escaping LocalhostConnector = AgentRuntime.canConnectToLocalhost,
+        whisperReadyTimeout: TimeInterval = 180
     ) {
         self.baseEnvironment = environment
         self.userDefaults = userDefaults
+        self.processRunner = processRunner
+        self.localhostConnector = localhostConnector
+        self.whisperReadyTimeout = whisperReadyTimeout
 
         if let override = environment["AGENTCLI_APP_SUPPORT_DIR"], !override.isEmpty {
             appSupportURL = URL(fileURLWithPath: override, isDirectory: true)
@@ -201,9 +215,9 @@ struct AgentRuntime {
         }
 
         let installDescription = "uv tool install agent-cli[audio,llm]"
-        let result = Self.runProcess(
-            executableURL: bundledUVURL,
-            arguments: [
+        let result = processRunner(
+            bundledUVURL,
+            [
                 "tool",
                 "install",
                 "--managed-python",
@@ -212,7 +226,7 @@ struct AgentRuntime {
                 "--force",
                 agentCLIInstallRequirement
             ],
-            environment: commandEnvironment()
+            commandEnvironment()
         )
         if result.exitCode != 0, result.output.isEmpty {
             return CommandResult(exitCode: result.exitCode, output: "\(installDescription) failed")
@@ -228,10 +242,10 @@ struct AgentRuntime {
     }
 
     private func ensureUserInstalledCLIAvailable() -> CommandResult {
-        let result = Self.runProcess(
-            executableURL: agentCLIExecutableURL,
-            arguments: agentCLIProcessArguments(["--version"]),
-            environment: commandEnvironment()
+        let result = processRunner(
+            agentCLIExecutableURL,
+            agentCLIProcessArguments(["--version"]),
+            commandEnvironment()
         )
         guard result.exitCode != 127 else {
             return CommandResult(
@@ -292,11 +306,17 @@ struct AgentRuntime {
     ) -> CommandResult {
         if !force, (try? String(contentsOf: whisperDaemonMarkerURL)) == whisperDaemonMarkerContents {
             progress(.waitingForVoiceService)
-            return waitForWhisperDaemonReady()
+            if localhostConnector(10300) {
+                return CommandResult(exitCode: 0, output: "")
+            }
         }
 
+        return installWhisperDaemon(progress: progress)
+    }
+
+    private func installWhisperDaemon(progress: AgentBootstrapProgress) -> CommandResult {
         progress(.installingVoiceService)
-        let result = runAgentCLI(arguments: ["daemon", "install", "whisper", "-y"])
+        let result = runAgentCLI(arguments: ["daemon", "ensure", "whisper", "--quiet"])
         guard result.exitCode == 0 else {
             return result
         }
@@ -395,10 +415,14 @@ struct AgentRuntime {
         }
     }
 
-    private func waitForWhisperDaemonReady(timeout: TimeInterval = 180) -> CommandResult {
+    private func waitForWhisperDaemonReady() -> CommandResult {
+        waitForWhisperDaemonReady(timeout: whisperReadyTimeout)
+    }
+
+    private func waitForWhisperDaemonReady(timeout: TimeInterval) -> CommandResult {
         let deadline = Date().addingTimeInterval(timeout)
         while Date() < deadline {
-            if Self.canConnectToLocalhost(port: 10300) {
+            if localhostConnector(10300) {
                 return CommandResult(exitCode: 0, output: "")
             }
             Thread.sleep(forTimeInterval: 0.5)
@@ -555,18 +579,18 @@ struct AgentRuntime {
     }
 
     func runShell(_ shell: String) -> CommandResult {
-        Self.runProcess(
-            executableURL: URL(fileURLWithPath: "/bin/zsh"),
-            arguments: ["-lc", shell],
-            environment: commandEnvironment()
+        processRunner(
+            URL(fileURLWithPath: "/bin/zsh"),
+            ["-lc", shell],
+            commandEnvironment()
         )
     }
 
     func runAgentCLI(arguments: [String]) -> CommandResult {
-        Self.runProcess(
-            executableURL: agentCLIExecutableURL,
-            arguments: agentCLIProcessArguments(arguments),
-            environment: commandEnvironment()
+        processRunner(
+            agentCLIExecutableURL,
+            agentCLIProcessArguments(arguments),
+            commandEnvironment()
         )
     }