@iamsamuelrodda/dictate 2026.5.18-1

package/install-windows.ps1

@@ -0,0 +1,330 @@
+param(
+    [switch]$NoVerify,
+    [switch]$NoPrepareTurbo,
+    [switch]$NoShortcut,
+    [switch]$NoStartup,
+    [switch]$RecreateVenv
+)
+
+$ErrorActionPreference = "Stop"
+
+function Test-PythonVersion {
+    param(
+        [string]$Exe,
+        [string[]]$ArgumentList
+    )
+
+    & $Exe @ArgumentList -c "import sys; raise SystemExit(0 if (3, 11) <= sys.version_info < (3, 13) else 1)" *> $null
+    return ($LASTEXITCODE -eq 0)
+}
+
+function Resolve-Python {
+    $candidates = @()
+
+    if ($env:PYTHON) {
+        $candidates += [pscustomobject]@{ Exe = $env:PYTHON; ArgumentList = @() }
+    }
+
+    $python = Get-Command python -ErrorAction SilentlyContinue
+    if ($python) {
+        $candidates += [pscustomobject]@{ Exe = $python.Source; ArgumentList = @() }
+    }
+
+    $python3 = Get-Command python3 -ErrorAction SilentlyContinue
+    if ($python3) {
+        $candidates += [pscustomobject]@{ Exe = $python3.Source; ArgumentList = @() }
+    }
+
+    $py = Get-Command py -ErrorAction SilentlyContinue
+    if ($py) {
+        $candidates += [pscustomobject]@{ Exe = $py.Source; ArgumentList = @("-3.12") }
+        $candidates += [pscustomobject]@{ Exe = $py.Source; ArgumentList = @("-3.11") }
+    }
+
+    foreach ($candidate in $candidates) {
+        if (Test-PythonVersion -Exe $candidate.Exe -ArgumentList $candidate.ArgumentList) {
+            return $candidate
+        }
+    }
+
+    throw "Python 3.11 or 3.12 was not found. Install Python from python.org or winget, then rerun this script."
+}
+
+function Invoke-Checked {
+    param(
+        [string]$Exe,
+        [string[]]$ArgumentList,
+        [string]$Description
+    )
+
+    Write-Host "==> $Description"
+    & $Exe @ArgumentList
+    if ($LASTEXITCODE -ne 0) {
+        throw "$Description failed with exit code $LASTEXITCODE."
+    }
+}
+
+function Test-VcRuntime {
+    $system32 = Join-Path $env:WINDIR "System32"
+    $required = @("vcruntime140.dll", "vcruntime140_1.dll", "msvcp140.dll")
+    foreach ($dll in $required) {
+        if (-not (Test-Path (Join-Path $system32 $dll))) {
+            return $false
+        }
+    }
+    return $true
+}
+
+function Ensure-VcRuntime {
+    if (Test-VcRuntime) {
+        Write-Host "==> Microsoft Visual C++ runtime already installed"
+        return
+    }
+
+    $installer = Join-Path $env:TEMP "vc_redist.x64.exe"
+    $url = "https://aka.ms/vs/17/release/vc_redist.x64.exe"
+    Write-Host "==> Installing Microsoft Visual C++ runtime"
+    Invoke-WebRequest -UseBasicParsing -Uri $url -OutFile $installer
+    $process = Start-Process -FilePath $installer -ArgumentList "/install", "/quiet", "/norestart" -Wait -PassThru
+    if (($process.ExitCode -ne 0) -and ($process.ExitCode -ne 3010)) {
+        throw "Microsoft Visual C++ runtime install failed with exit code $($process.ExitCode)."
+    }
+}
+
+function Get-AppDataConfigPath {
+    $base = $env:APPDATA
+    if (-not $base) {
+        $base = Join-Path $HOME "AppData\Roaming"
+    }
+    return Join-Path $base "dictate\config.yaml"
+}
+
+function Seed-Config {
+    $configPath = Get-AppDataConfigPath
+    if (Test-Path $configPath) {
+        Write-Host "==> Config already exists: $configPath"
+        return
+    }
+
+    $defaultConfig = Join-Path $PSScriptRoot "config\default-config.yaml"
+    $configDir = Split-Path -Parent $configPath
+    New-Item -ItemType Directory -Force -Path $configDir | Out-Null
+    Copy-Item -Path $defaultConfig -Destination $configPath
+    Write-Host "==> Seeded config: $configPath"
+}
+
+function Write-LauncherScripts {
+    param([string]$ScriptsDir)
+
+    $daemonPath = Join-Path $ScriptsDir "dictate-daemon.cmd"
+    $oncePath = Join-Path $ScriptsDir "dictate-once.cmd"
+    $controlsPath = Join-Path $ScriptsDir "dictate-controls.cmd"
+    $trayPath = Join-Path $ScriptsDir "dictate-tray.cmd"
+    $trayVbsPath = Join-Path $ScriptsDir "dictate-tray.vbs"
+
+    Set-Content -Path $trayPath -Encoding ASCII -Value @(
+        "@echo off",
+        'set "SCRIPT_DIR=%~dp0"',
+        '"%SCRIPT_DIR%dictate.exe" --type-backend pynput %*'
+    )
+
+    Set-Content -Path $daemonPath -Encoding ASCII -Value @(
+        "@echo off",
+        'set "SCRIPT_DIR=%~dp0"',
+        '"%SCRIPT_DIR%dictate.exe" --no-tray --type-backend pynput %*'
+    )
+
+    Set-Content -Path $oncePath -Encoding ASCII -Value @(
+        "@echo off",
+        'set "SCRIPT_DIR=%~dp0"',
+        '"%SCRIPT_DIR%dictate.exe" --once %*'
+    )
+
+    Set-Content -Path $controlsPath -Encoding ASCII -Value @(
+        "@echo off",
+        'set "SCRIPT_DIR=%~dp0"',
+        'start "" "%SCRIPT_DIR%dictate-controls.exe" %*'
+    )
+
+    Set-Content -Path $trayVbsPath -Encoding ASCII -Value @(
+        'Set shell = CreateObject("WScript.Shell")',
+        'Set fso = CreateObject("Scripting.FileSystemObject")',
+        'scriptDir = fso.GetParentFolderName(WScript.ScriptFullName)',
+        'venvDir = fso.GetParentFolderName(scriptDir)',
+        'shell.CurrentDirectory = fso.GetParentFolderName(venvDir)',
+        'shell.Run """" & scriptDir & "\pythonw.exe"" -m dictate --type-backend pynput", 0, False'
+    )
+
+    Write-Host "==> Wrote launchers:"
+    Write-Host "    $trayPath"
+    Write-Host "    $trayVbsPath"
+    Write-Host "    $daemonPath"
+    Write-Host "    $oncePath"
+    Write-Host "    $controlsPath"
+}
+
+function Get-StartMenuProgramsDir {
+    $programsDir = Join-Path $env:APPDATA "Microsoft\Windows\Start Menu\Programs"
+    if (-not $env:APPDATA) {
+        $programsDir = Join-Path $HOME "AppData\Roaming\Microsoft\Windows\Start Menu\Programs"
+    }
+    return $programsDir
+}
+
+function Get-StartupDir {
+    return (Join-Path (Get-StartMenuProgramsDir) "Startup")
+}
+
+function New-DictateShortcut {
+    param(
+        [string]$ShortcutPath,
+        [string]$TargetPath,
+        [string]$Arguments = "",
+        [string]$WorkingDirectory,
+        [string]$Description
+    )
+
+    $iconPath = Join-Path $PSScriptRoot "assets\dictate.ico"
+    $shell = New-Object -ComObject WScript.Shell
+    $shortcut = $shell.CreateShortcut($ShortcutPath)
+    $shortcut.TargetPath = $TargetPath
+    $shortcut.Arguments = $Arguments
+    $shortcut.WorkingDirectory = $WorkingDirectory
+    $shortcut.Description = $Description
+    if (Test-Path $iconPath) {
+        $shortcut.IconLocation = $iconPath
+    }
+    $shortcut.Save()
+}
+
+function Install-StartMenuShortcut {
+    param(
+        [string]$TargetPath,
+        [string]$Arguments = "",
+        [string]$WorkingDirectory
+    )
+
+    $programsDir = Get-StartMenuProgramsDir
+    New-Item -ItemType Directory -Force -Path $programsDir | Out-Null
+
+    $shortcutPath = Join-Path $programsDir "Dictate.lnk"
+    $legacyShortcutPath = Join-Path $programsDir "Dictate Controls.lnk"
+
+    if ($NoShortcut) {
+        Remove-Item -Force -ErrorAction SilentlyContinue -Path $shortcutPath, $legacyShortcutPath
+        Write-Host "==> Removed Start Menu shortcuts"
+        return
+    }
+
+    Remove-Item -Force -ErrorAction SilentlyContinue -Path $legacyShortcutPath
+    New-DictateShortcut -ShortcutPath $shortcutPath -TargetPath $TargetPath -Arguments $Arguments -WorkingDirectory $WorkingDirectory -Description "Start Dictate push-to-talk tray"
+
+    Write-Host "==> Installed Start Menu shortcut: $shortcutPath"
+}
+
+function Install-StartupShortcut {
+    param(
+        [string]$TargetPath,
+        [string]$Arguments = "",
+        [string]$WorkingDirectory
+    )
+
+    if ($NoShortcut -or $NoStartup) {
+        $startupDir = Get-StartupDir
+        $shortcutPath = Join-Path $startupDir "Dictate.lnk"
+        if (Test-Path $shortcutPath) {
+            Remove-Item -Force $shortcutPath
+            Write-Host "==> Removed startup shortcut: $shortcutPath"
+        }
+        return
+    }
+
+    $startupDir = Get-StartupDir
+    New-Item -ItemType Directory -Force -Path $startupDir | Out-Null
+
+    $shortcutPath = Join-Path $startupDir "Dictate.lnk"
+    New-DictateShortcut -ShortcutPath $shortcutPath -TargetPath $TargetPath -Arguments $Arguments -WorkingDirectory $WorkingDirectory -Description "Start Dictate automatically at sign-in"
+
+    Write-Host "==> Installed startup shortcut: $shortcutPath"
+}
+
+function Register-InstalledApp {
+    param(
+        [string]$InstallLocation,
+        [string]$DisplayIcon
+    )
+
+    $keyPath = "HKCU:\Software\Microsoft\Windows\CurrentVersion\Uninstall\Dictate"
+    New-Item -Force -Path $keyPath | Out-Null
+    New-ItemProperty -Force -Path $keyPath -Name "DisplayName" -Value "Dictate" -PropertyType String | Out-Null
+    New-ItemProperty -Force -Path $keyPath -Name "DisplayVersion" -Value "2026.5.18-1" -PropertyType String | Out-Null
+    New-ItemProperty -Force -Path $keyPath -Name "Publisher" -Value "Arc Forge Labs" -PropertyType String | Out-Null
+    New-ItemProperty -Force -Path $keyPath -Name "InstallLocation" -Value $InstallLocation -PropertyType String | Out-Null
+    if (Test-Path $DisplayIcon) {
+        New-ItemProperty -Force -Path $keyPath -Name "DisplayIcon" -Value $DisplayIcon -PropertyType String | Out-Null
+    }
+    $uninstallScript = Join-Path $InstallLocation "uninstall-windows.ps1"
+    if (Test-Path $uninstallScript) {
+        $uninstallCommand = "powershell -NoProfile -ExecutionPolicy Bypass -File `"$uninstallScript`""
+        New-ItemProperty -Force -Path $keyPath -Name "UninstallString" -Value $uninstallCommand -PropertyType String | Out-Null
+        New-ItemProperty -Force -Path $keyPath -Name "QuietUninstallString" -Value "$uninstallCommand -Quiet" -PropertyType String | Out-Null
+    }
+    New-ItemProperty -Force -Path $keyPath -Name "NoModify" -Value 1 -PropertyType DWord | Out-Null
+    New-ItemProperty -Force -Path $keyPath -Name "NoRepair" -Value 1 -PropertyType DWord | Out-Null
+    Write-Host "==> Registered Dictate in Windows Installed Apps"
+}
+
+$pythonCommand = Resolve-Python
+$venvDir = Join-Path $PSScriptRoot ".venv"
+$scriptsDir = Join-Path $venvDir "Scripts"
+$venvPython = Join-Path $scriptsDir "python.exe"
+
+Ensure-VcRuntime
+
+if ($RecreateVenv -and (Test-Path $venvDir)) {
+    Write-Host "==> Removing existing virtual environment: $venvDir"
+    Remove-Item -Recurse -Force $venvDir
+}
+
+if (-not (Test-Path $venvPython)) {
+    Invoke-Checked -Exe $pythonCommand.Exe -ArgumentList @($pythonCommand.ArgumentList + @("-m", "venv", $venvDir)) -Description "Creating virtual environment"
+}
+
+Invoke-Checked -Exe $venvPython -ArgumentList @("-m", "pip", "install", "--upgrade", "pip") -Description "Upgrading pip"
+Invoke-Checked -Exe $venvPython -ArgumentList @("-m", "pip", "install", "-e", "${PSScriptRoot}[windows]") -Description "Installing Dictate Windows package"
+
+Seed-Config
+Write-LauncherScripts -ScriptsDir $scriptsDir
+$trayVbs = Join-Path $scriptsDir "dictate-tray.vbs"
+$wscript = Join-Path $env:WINDIR "System32\wscript.exe"
+$trayArgs = "`"$trayVbs`""
+Install-StartMenuShortcut -TargetPath $wscript -Arguments $trayArgs -WorkingDirectory $PSScriptRoot
+Install-StartupShortcut -TargetPath $wscript -Arguments $trayArgs -WorkingDirectory $PSScriptRoot
+Register-InstalledApp -InstallLocation $PSScriptRoot -DisplayIcon (Join-Path $PSScriptRoot "assets\dictate.ico")
+
+if (-not $NoPrepareTurbo) {
+    Invoke-Checked -Exe $venvPython -ArgumentList @("-m", "dictate", "prepare-model", "--stt-backend", "faster-whisper", "--model", "turbo", "--device", "auto", "--compute-type", "int8") -Description "Preparing faster-whisper turbo model"
+}
+
+if (-not $NoVerify) {
+    Invoke-Checked -Exe $venvPython -ArgumentList @("-m", "dictate", "doctor", "--quick", "--type-backend", "pynput") -Description "Running Dictate doctor"
+}
+
+Write-Host ""
+Write-Host "Dictate is installed."
+if ($NoShortcut -or $NoStartup) {
+    Write-Host "Dictate startup shortcut was not installed."
+} else {
+    Write-Host "Dictate starts automatically when you sign in."
+}
+Write-Host "Start push-to-talk with a Windows tray icon from the Start Menu shortcut named 'Dictate', or run:"
+Write-Host "  .\.venv\Scripts\dictate-tray.cmd"
+Write-Host ""
+Write-Host "Headless push-to-talk daemon:"
+Write-Host "  .\.venv\Scripts\dictate-daemon.cmd"
+Write-Host ""
+Write-Host "Control panel:"
+Write-Host "  .\.venv\Scripts\dictate-controls.cmd"
+Write-Host ""
+Write-Host "One-shot mode:"
+Write-Host "  .\.venv\Scripts\dictate-once.cmd"

package/install.ps1

@@ -0,0 +1,87 @@
+param(
+    [string]$InstallRoot,
+    [string]$ArchiveUrl,
+    [switch]$NoVerify,
+    [switch]$NoPrepareTurbo,
+    [switch]$NoShortcut,
+    [switch]$NoStartup,
+    [switch]$Wizard,
+    [switch]$RecreateVenv
+)
+
+$ErrorActionPreference = "Stop"
+$DictateVersion = "2026.5.18-1"
+
+if (-not $ArchiveUrl) {
+    $ArchiveUrl = "https://github.com/arcforgelabs/dictate/archive/refs/tags/v$DictateVersion.zip"
+}
+
+if (-not $InstallRoot) {
+    $base = $env:LOCALAPPDATA
+    if (-not $base) {
+        $base = Join-Path $HOME "AppData\Local"
+    }
+    $InstallRoot = Join-Path $base "Dictate"
+}
+
+$installRootPath = [System.IO.Path]::GetFullPath($InstallRoot)
+$sourceDir = Join-Path $installRootPath "source"
+$stagingRoot = Join-Path $env:TEMP ("dictate-install-" + [guid]::NewGuid().ToString("N"))
+$archivePath = Join-Path $stagingRoot "dictate.zip"
+
+Write-Host "==> Installing Dictate to $installRootPath"
+New-Item -ItemType Directory -Force -Path $stagingRoot | Out-Null
+New-Item -ItemType Directory -Force -Path $installRootPath | Out-Null
+
+try {
+    if (Test-Path -LiteralPath $ArchiveUrl) {
+        Write-Host "==> Copying local archive $ArchiveUrl"
+        Copy-Item -Force -LiteralPath $ArchiveUrl -Destination $archivePath
+    } else {
+        Write-Host "==> Downloading $ArchiveUrl"
+        Invoke-WebRequest -UseBasicParsing -Uri $ArchiveUrl -OutFile $archivePath
+    }
+
+    Write-Host "==> Expanding source archive"
+    Expand-Archive -Force -Path $archivePath -DestinationPath $stagingRoot
+    $expanded = Get-ChildItem -Path $stagingRoot -Directory |
+        Where-Object { Test-Path (Join-Path $_.FullName "install-windows.ps1") } |
+        Select-Object -First 1
+    if (-not $expanded) {
+        throw "Downloaded archive did not contain install-windows.ps1."
+    }
+
+    if (Test-Path $sourceDir) {
+        Write-Host "==> Replacing existing managed source: $sourceDir"
+        Remove-Item -Recurse -Force $sourceDir
+    }
+    Move-Item -Path $expanded.FullName -Destination $sourceDir
+
+    $installerScript = if ($Wizard) {
+        Join-Path $sourceDir "install-windows-wizard.ps1"
+    } else {
+        Join-Path $sourceDir "install-windows.ps1"
+    }
+    $installerArgs = @("-ExecutionPolicy", "Bypass", "-File", $installerScript)
+    if (-not $Wizard) {
+        if ($NoVerify) { $installerArgs += "-NoVerify" }
+        if ($NoPrepareTurbo) { $installerArgs += "-NoPrepareTurbo" }
+        if ($NoShortcut) { $installerArgs += "-NoShortcut" }
+        if ($NoStartup) { $installerArgs += "-NoStartup" }
+        if ($RecreateVenv) { $installerArgs += "-RecreateVenv" }
+    }
+
+    Write-Host "==> Running Dictate Windows installer"
+    & powershell @installerArgs
+    if ($LASTEXITCODE -ne 0) {
+        throw "Dictate Windows installer failed with exit code $LASTEXITCODE."
+    }
+} finally {
+    if (Test-Path $stagingRoot) {
+        Remove-Item -Recurse -Force $stagingRoot
+    }
+}
+
+Write-Host ""
+Write-Host "Dictate install source: $sourceDir"
+Write-Host "Start Dictate from the Start Menu shortcut named 'Dictate'."

package/install.sh

@@ -0,0 +1,233 @@
+#!/usr/bin/env bash
+# Install/update dictate into a standalone venv at ~/.local/share/dictate.
+# Uses --system-site-packages so GTK/gi bindings are available.
+# Re-run this script after pulling changes to update the installation.
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+INSTALL_DIR="$HOME/.local/share/dictate"
+BIN_DIR="$HOME/.local/bin"
+DESKTOP_DIR="${XDG_DATA_HOME:-$HOME/.local/share}/applications"
+AUTOSTART_DIR="${XDG_CONFIG_HOME:-$HOME/.config}/autostart"
+ICON_DIR="$INSTALL_DIR/share/icons"
+ICON_PATH="$ICON_DIR/dictate-simple.png"
+CONFIG_DIR="${XDG_CONFIG_HOME:-$HOME/.config}/dictate"
+CONFIG_PATH="$CONFIG_DIR/config.yaml"
+DEFAULT_CONFIG_SOURCE="$SCRIPT_DIR/config/default-config.yaml"
+VERIFY=1
+PREPARE_TURBO=1
+SEED_DEFAULT_CONFIG=1
+STARTUP=1
+PYTHON_BIN="${PYTHON_BIN:-python3}"
+
+# Prefer the distro Python so --system-site-packages can see modules such as
+# python3-gi from /usr/lib/python3/dist-packages.
+if [ -x /usr/bin/python3 ]; then
+  PYTHON_BIN="/usr/bin/python3"
+fi
+
+usage() {
+  cat <<EOF
+Usage: $0 [--no-verify] [--no-prepare-turbo] [--no-seed-default-config] [--no-startup] [--session-backend auto|x11|wayland]
+
+Installs dictate into ~/.local/share/dictate, links ~/.local/bin/dictate,
+seeds the default config on first install, creates app launcher/autostart entries,
+and prepares the faster-whisper turbo model unless disabled.
+EOF
+}
+
+detect_session_backend() {
+  if [ -n "${WAYLAND_DISPLAY:-}" ] || [ "${XDG_SESSION_TYPE:-}" = "wayland" ]; then
+    printf 'wayland\n'
+    return
+  fi
+  if [ -n "${DISPLAY:-}" ] || [ "${XDG_SESSION_TYPE:-}" = "x11" ]; then
+    printf 'x11\n'
+    return
+  fi
+  if [ -n "${XDG_SESSION_ID:-}" ] && command -v loginctl >/dev/null 2>&1; then
+    local detected
+    detected="$(loginctl show-session "$XDG_SESSION_ID" -p Type --value 2>/dev/null || true)"
+    if [ "$detected" = "wayland" ] || [ "$detected" = "x11" ]; then
+      printf '%s\n' "$detected"
+      return
+    fi
+  fi
+  printf 'unknown\n'
+}
+
+SESSION_BACKEND="auto"
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --no-verify)
+      VERIFY=0
+      ;;
+    --no-prepare-turbo)
+      PREPARE_TURBO=0
+      ;;
+    --no-seed-default-config)
+      SEED_DEFAULT_CONFIG=0
+      ;;
+    --no-startup)
+      STARTUP=0
+      ;;
+    --session-backend)
+      shift
+      SESSION_BACKEND="${1:-}"
+      ;;
+    --session-backend=*)
+      SESSION_BACKEND="${1#*=}"
+      ;;
+    -h|--help)
+      usage
+      exit 0
+      ;;
+    *)
+      usage
+      exit 1
+      ;;
+  esac
+  shift
+done
+
+if [ "$SESSION_BACKEND" = "auto" ]; then
+  SESSION_BACKEND="$(detect_session_backend)"
+fi
+
+PIP_TARGET="$SCRIPT_DIR"
+if [ "$SESSION_BACKEND" = "x11" ]; then
+  PIP_TARGET="${SCRIPT_DIR}[x11]"
+elif [ "$SESSION_BACKEND" = "wayland" ]; then
+  PIP_TARGET="${SCRIPT_DIR}[wayland]"
+elif [ "$SESSION_BACKEND" = "unknown" ]; then
+  PIP_TARGET="${SCRIPT_DIR}[x11,wayland]"
+fi
+
+echo "Detected install session backend: $SESSION_BACKEND"
+
+echo "Creating venv at $INSTALL_DIR ..."
+uv venv "$INSTALL_DIR/venv" --python "$PYTHON_BIN" --system-site-packages --quiet
+
+echo "Installing dictate from $PIP_TARGET ..."
+uv pip install "$PIP_TARGET" --python "$INSTALL_DIR/venv/bin/python" --quiet
+
+echo "Linking binary ..."
+mkdir -p "$BIN_DIR"
+ln -sf "$INSTALL_DIR/venv/bin/dictate" "$BIN_DIR/dictate"
+
+echo "Installing icon ..."
+mkdir -p "$ICON_DIR"
+rm -f "$ICON_DIR/dictate-controls.png" "$ICON_DIR/dictate.png"
+install -m 644 "$SCRIPT_DIR/assets/dictate.png" "$ICON_PATH"
+
+echo "Installing desktop entry ..."
+mkdir -p "$DESKTOP_DIR"
+rm -f "$DESKTOP_DIR/dictate-settings.desktop"
+cat > "$DESKTOP_DIR/dictate.desktop" <<EOF
+[Desktop Entry]
+Name=Dictate
+Comment=Dictate into the focused app
+Exec=$HOME/.local/bin/dictate
+Icon=$ICON_PATH
+Type=Application
+Categories=AudioVideo;Audio;
+Keywords=voice;speech;transcription;dictation;asr;whisper;canary;
+Terminal=false
+EOF
+
+update-desktop-database "$DESKTOP_DIR" 2>/dev/null || true
+
+if [ "$STARTUP" -eq 1 ]; then
+  echo "Installing autostart entry ..."
+  mkdir -p "$AUTOSTART_DIR"
+  cat > "$AUTOSTART_DIR/dictate.desktop" <<EOF
+[Desktop Entry]
+Name=Dictate
+Comment=Dictate into the focused app
+Exec=$HOME/.local/bin/dictate
+Icon=$ICON_PATH
+Type=Application
+Categories=AudioVideo;Audio;
+Keywords=voice;speech;transcription;dictation;asr;whisper;canary;
+Terminal=false
+X-GNOME-Autostart-enabled=true
+EOF
+fi
+
+if [ "$SEED_DEFAULT_CONFIG" -eq 1 ]; then
+  if [ ! -f "$CONFIG_PATH" ]; then
+    if [ ! -f "$DEFAULT_CONFIG_SOURCE" ]; then
+      echo "Default config template not found: $DEFAULT_CONFIG_SOURCE"
+      exit 1
+    fi
+    echo "Seeding default config at $CONFIG_PATH ..."
+    mkdir -p "$CONFIG_DIR"
+    install -m 600 "$DEFAULT_CONFIG_SOURCE" "$CONFIG_PATH"
+    if [ "$SESSION_BACKEND" = "wayland" ]; then
+      sed -i 's/^push_to_talk_combo: .*/push_to_talk_combo: ctrl+space/' "$CONFIG_PATH"
+    fi
+  else
+    echo "Existing config found at $CONFIG_PATH; leaving it unchanged."
+  fi
+fi
+
+DICTATE_BIN="$INSTALL_DIR/venv/bin/dictate"
+
+run_logged_check() {
+  local label="$1"
+  local log_path="$2"
+  local timeout_seconds="$3"
+  shift 3
+  echo "Running: $label ..."
+  if command -v timeout >/dev/null 2>&1; then
+    if ! timeout "${timeout_seconds}s" "$@" >"$log_path" 2>&1; then
+      echo "Command failed: $label"
+      echo "See: $log_path"
+      tail -n 120 "$log_path" || true
+      exit 1
+    fi
+  else
+    if ! "$@" >"$log_path" 2>&1; then
+      echo "Command failed: $label"
+      echo "See: $log_path"
+      tail -n 120 "$log_path" || true
+      exit 1
+    fi
+  fi
+}
+
+if [ "$PREPARE_TURBO" -eq 1 ]; then
+  PREPARE_LOG="/tmp/dictate-install-prepare.log"
+  run_logged_check \
+    "dictate prepare-model --stt-backend faster-whisper --model turbo --device auto --compute-type int8" \
+    "$PREPARE_LOG" \
+    1800 \
+    "$DICTATE_BIN" \
+    prepare-model \
+    --stt-backend faster-whisper \
+    --model turbo \
+    --device auto \
+    --compute-type int8
+fi
+
+if [ "$VERIFY" -eq 1 ]; then
+  VERIFY_LOG="/tmp/dictate-install-verify.log"
+  run_logged_check "dictate --help" "$VERIFY_LOG" 20 "$DICTATE_BIN" --help
+  run_logged_check "dictate benchmark --help" "$VERIFY_LOG" 20 "$DICTATE_BIN" benchmark --help
+  run_logged_check \
+    "dictate doctor --quick --stt-backend faster-whisper --model turbo" \
+    "$VERIFY_LOG" \
+    20 \
+    "$DICTATE_BIN" \
+    doctor \
+    --quick \
+    --stt-backend faster-whisper \
+    --model turbo
+fi
+
+if [ "$STARTUP" -eq 1 ]; then
+  echo "Done. 'dictate' is now available on your PATH, in the app launcher, and starts when you sign in."
+else
+  echo "Done. 'dictate' is now available on your PATH and in the app launcher."
+fi

package/npm/dictate-lifecycle.mjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const packageRoot = dirname(scriptDir);
+const invokedAs = basename(process.argv[1] || "dictate-install");
+const firstArg = process.argv[2] || "";
+
+let command = "install";
+let passthrough = process.argv.slice(2);
+if (invokedAs.includes("update")) {
+  command = "update";
+} else if (invokedAs.includes("uninstall")) {
+  command = "uninstall";
+} else if (["install", "update", "uninstall", "wizard"].includes(firstArg)) {
+  command = firstArg;
+  passthrough = process.argv.slice(3);
+}
+
+const isWindows = process.platform === "win32";
+const scripts = isWindows
+  ? {
+      install: ["powershell.exe", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", join(packageRoot, "install.ps1")]],
+      update: ["powershell.exe", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", join(packageRoot, "update.ps1")]],
+      uninstall: ["powershell.exe", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", join(packageRoot, "uninstall.ps1")]],
+      wizard: ["powershell.exe", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", join(packageRoot, "install.ps1"), "-Wizard"]],
+    }
+  : {
+      install: ["bash", [join(packageRoot, "install.sh")]],
+      update: ["bash", [join(packageRoot, "update.sh")]],
+      uninstall: ["bash", [join(packageRoot, "uninstall.sh")]],
+      wizard: null,
+    };
+
+const selected = scripts[command];
+if (!selected) {
+  console.error(`dictate ${command} is not supported on ${process.platform}`);
+  process.exit(2);
+}
+
+const [exe, args] = selected;
+const result = spawnSync(exe, [...args, ...passthrough], { stdio: "inherit" });
+if (result.error) {
+  console.error(result.error.message);
+  process.exit(1);
+}
+process.exit(result.status ?? 1);