Hands-on lab — Day 13: Package Managers: Homebrew, apt, and winget

# Package Manager Command Cheat Sheet

The same task, three managers. Learn the model once and read across the row.
Commands that change the system are marked; this lab runs only the read-only
ones (search, list, version, info).

| Task | Homebrew (macOS) | apt (Debian/Ubuntu) | winget (Windows) |
| --- | --- | --- | --- |
| Show the manager's version | `brew --version` | `apt --version` | `winget --version` |
| Refresh the repository index | `brew update` | `sudo apt update` | (automatic) |
| Search for a package | `brew search wget` | `apt search wget` | `winget search wget` |
| Show info about a package | `brew info wget` | `apt show wget` | `winget show wget` |
| **Install** a package | `brew install wget` | `sudo apt install wget` | `winget install wget` |
| List installed packages | `brew list` | `apt list --installed` | `winget list` |
| **Upgrade** everything | `brew upgrade` | `sudo apt upgrade` | `winget upgrade --all` |
| **Remove** a package | `brew uninstall wget` | `sudo apt remove wget` | `winget uninstall wget` |
| Show a package's dependencies | `brew deps --tree wget` | `apt-cache depends wget` | (see `winget show`) |

## Notes

- **sudo:** apt installs system-wide, so its *changing* commands (install,
  upgrade, remove) need administrator rights via `sudo`. Homebrew installs into
  your user space and normally does not. On Windows, winget may prompt for
  elevation for some installers.
- **update vs upgrade (apt):** `apt update` refreshes the local copy of the
  repository index; `apt upgrade` actually moves installed packages to newer
  versions. They are different commands — do not confuse them.
- **Read-only vs changing:** version, search, info, list, and dependency
  queries change nothing and are safe to explore with. Install, upgrade, and
  remove change your system — run them deliberately.
- **Language managers:** `pip install <name>` (Python) and `npm install <name>`
  (Node.js) follow the same model one layer down, for code libraries rather
  than whole applications. You will meet them in a later lesson.

#!/usr/bin/env bash
# Day 013 lab — completed reference implementation.
#
# Detects which package managers are available on THIS machine and runs one
# safe, READ-ONLY query against each one it finds. It never installs, removes,
# or upgrades anything, never uses sudo, and needs no network connection.
#
# Detected: brew, apt, apt-get, winget, pip, pip3, npm.
set -u

echo "=== Package Manager Report ==="
echo "Generated on: $(date '+%Y-%m-%d')"
echo "Operating system kernel: $(uname -s)"
echo

found=0

# have <name> -> prints the resolved path if the command exists, else nothing.
have() {
  command -v "$1" 2>/dev/null
}

# header <name> -> if <name> exists, print the FOUND line and return 0.
header() {
  local path
  path="$(have "$1")"
  if [ -n "${path}" ]; then
    found=$((found + 1))
    echo "FOUND: $1 -> ${path}"
    return 0
  fi
  return 1
}

# query <description> <command...> -> label and run a read-only query, indented.
query() {
  local desc="$1"
  shift
  echo "  read-only query: ${desc}"
  "$@" 2>&1 | sed 's/^/    /' | head -n 6
}

# --- System package managers -------------------------------------------
if header brew; then
  query "brew --version" brew --version
  query "brew list | head" bash -c 'brew list 2>/dev/null | head -n 5'
  echo
fi

if header apt; then
  query "apt-cache policy (configured repositories)" apt-cache policy
  echo
elif header apt-get; then
  query "apt-cache policy (configured repositories)" apt-cache policy
  echo
fi

if header winget; then
  query "winget --version" winget --version
  echo
fi

# --- Language package managers -----------------------------------------
if header pip; then
  query "pip --version" pip --version
  echo
elif header pip3; then
  query "pip3 --version" pip3 --version
  echo
fi

if header npm; then
  query "npm --version" npm --version
  echo
fi

echo "----------------------------------------"
if [ "${found}" -eq 0 ]; then
  echo "No package managers detected on this machine."
  echo "That is a valid result: on macOS you may not have Homebrew yet; on"
  echo "minimal Linux, apt should be present. Nothing was installed."
else
  echo "Detected ${found} package manager(s) above (read-only)."
  echo "Nothing was installed, removed, or upgraded."
fi
echo "=== End of report ==="

lesson_id: D013
day: 13
kind: command-line-inspection
languages: [bash]
setup_commands:
  - cd labs/sections/computing-foundations/day-013-package-managers-homebrew-apt-and-winget
run_commands:
  - bash examples/detect_pkg_manager.sh
  - bash starter/detect_pkg_manager.sh
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - 'git checkout -- starter/detect_pkg_manager.sh  # optional: reset your work'
requires_network: false
requires_api_key: false
estimated_minutes: 30
last_executed: '2026-07-12'
executed_on: 'macOS (Apple Silicon), bash tests/run_tests.sh → 14 checks, 0 failure(s); detector found brew, pip, npm'

# Dependencies — Day 013 lab

**None beyond a POSIX shell.** This lab intentionally has zero installable
dependencies — fitting, since its whole subject is installing software:

- `bash` ≥ 3.2 (preinstalled on macOS and every mainstream Linux distribution)
- Standard OS utilities: `command`, `uname`, `date`, `sed`, `grep`, `head` —
  all part of the base system.

The lab only *detects and inspects* the package managers you already have; it
installs nothing and needs no network connection. If a manager the script looks
for (brew, apt, apt-get, winget, pip, pip3, npm) is absent, that is simply
reported and is a valid result — you do not need to install anything to
complete the lab.

There is deliberately no `requirements.txt`/`package.json` here.

#!/usr/bin/env bash
# Day 013 lab — YOUR working file.
#
# This starter already prints the report header and detects package managers
# for you. Your task is the four numbered exercises below: each asks you to add
# ONE safe, READ-ONLY query for a manager. Every command you add must be
# read-only — no install, no remove, no upgrade, no sudo, no network required.
#
# The completed reference version is examples/detect_pkg_manager.sh — try the
# exercises yourself first, then compare.
set -u

echo "=== Package Manager Report ==="
echo "Generated on: $(date '+%Y-%m-%d')"
echo "Operating system kernel: $(uname -s)"
echo

found=0

have() { command -v "$1" 2>/dev/null; }

header() {
  local path
  path="$(have "$1")"
  if [ -n "${path}" ]; then
    found=$((found + 1))
    echo "FOUND: $1 -> ${path}"
    return 0
  fi
  return 1
}

query() {
  local desc="$1"; shift
  echo "  read-only query: ${desc}"
  "$@" 2>&1 | sed 's/^/    /' | head -n 6
}

# --- System package managers -------------------------------------------
if header brew; then
  # Exercise 1 (Homebrew): add a read-only query that prints Homebrew's version.
  #   Use exactly:  query "brew --version" brew --version
  echo "  (exercise 1: add the brew --version query here)"
  echo
fi

if header apt || header apt-get; then
  # Exercise 2 (apt): add a read-only query that shows the configured repositories
  # WITHOUT changing anything. Use exactly:
  #   query "apt-cache policy" apt-cache policy
  echo "  (exercise 2: add the apt-cache policy query here)"
  echo
fi

if header winget; then
  # Exercise 3 (winget): add a read-only query that prints winget's version.
  #   Use exactly:  query "winget --version" winget --version
  echo "  (exercise 3: add the winget --version query here)"
  echo
fi

# --- Language package managers -----------------------------------------
if header pip || header pip3; then
  # Exercise 4 (pip): add a read-only query that prints pip's version. Use the
  # name that exists on your machine, for example:
  #   query "pip3 --version" pip3 --version
  echo "  (exercise 4: add the pip/pip3 --version query here)"
  echo
fi

if header npm; then
  query "npm --version" npm --version
  echo
fi

echo "----------------------------------------"
if [ "${found}" -eq 0 ]; then
  echo "No package managers detected on this machine."
  echo "That is a valid result: nothing was installed."
else
  echo "Detected ${found} package manager(s) above (read-only)."
  echo "Nothing was installed, removed, or upgraded."
fi
echo "=== End of report ==="

# Package Manager Worksheet — Day 013

Fill this in for **your** machine using the read-only commands from the lab.
Do **not** run any install command — this worksheet only records what you find
and what you *would* type.

## 1. Which package managers does your machine have?

Run `command -v brew apt apt-get winget pip pip3 npm` (or `bash examples/detect_pkg_manager.sh`)
and list every one it found:

- Package manager(s) found: `__________________________`

## 2. Your default system package manager

Based on your operating system, which is the *default* system package manager?
(macOS → Homebrew; Debian/Ubuntu → apt; Windows → winget.)

- My operating system: `__________________________`
- My default system package manager: `__________________________`

## 3. How you would install `wget` (write it — do NOT run it)

Write the exact command you *would* use to install the `wget` package on your
operating system. Do not run it.

- Install command for `wget`: `__________________________`

  (macOS: `brew install wget` · Debian/Ubuntu: `sudo apt install wget` · Windows: `winget install wget`)

## 4. One package you already have installed

List one package that is already installed, from `brew list`,
`apt list --installed`, or `winget list`:

- A package I already have: `__________________________`

## 5. Short reflection (4–6 sentences)

In your own words, explain why installing that one package with a package
manager was safer and more repeatable than downloading it by hand. Name
**dependency resolution**, **integrity verification**, and **record-keeping**
explicitly.

```
Your paragraph here:



```

#!/usr/bin/env bash
# Tests for the Day 013 lab. Run from the lab directory:
#   bash tests/run_tests.sh
#
# Verifies that the detector runs, produces a well-formed report that either
# lists at least one manager or states clearly that none were detected, and
# exits 0. It ALSO statically checks that the scripts contain no install,
# remove, upgrade, or sudo commands — this lab is strictly read-only.
set -u

lab_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
failures=0
checks=0

check() {
  local label="$1" ok="$2"
  checks=$((checks + 1))
  if [ "${ok}" = "yes" ]; then
    echo "  ok: ${label}"
  else
    echo "  FAIL: ${label}"
    failures=$((failures + 1))
  fi
}

run_report_checks() {
  local script="$1" output rc
  echo "Testing ${script} ..."
  output="$(bash "${script}" 2>&1)"
  rc=$?
  [ "${rc}" -eq 0 ] && check "script exits 0" "yes" || check "script exits 0" "no"
  echo "${output}" | grep -q '^=== Package Manager Report ===$' \
    && check "prints report header" "yes" || check "prints report header" "no"
  echo "${output}" | grep -q '^=== End of report ===$' \
    && check "prints report footer" "yes" || check "prints report footer" "no"
  echo "${output}" | grep -q '^Operating system kernel: ' \
    && check "prints OS kernel line" "yes" || check "prints OS kernel line" "no"
  # Either at least one manager was found, or a clear "none detected" message.
  if echo "${output}" | grep -q '^FOUND: ' \
    || echo "${output}" | grep -q 'No package managers detected'; then
    check "reports a manager OR a clear 'none detected' message" "yes"
  else
    check "reports a manager OR a clear 'none detected' message" "no"
  fi
}

# Static safety check: no mutating or privileged commands anywhere in the lab
# scripts. This lab must never install, remove, upgrade, or use sudo.
check_read_only() {
  local script="$1"
  echo "Safety-scanning ${script} ..."
  # Strip comment lines, then look for dangerous verbs as commands.
  local body
  body="$(grep -v '^[[:space:]]*#' "${script}")"
  if echo "${body}" | grep -Eq '\b(sudo)\b'; then
    check "no sudo in ${script##*/}" "no"
  else
    check "no sudo in ${script##*/}" "yes"
  fi
  if echo "${body}" | grep -Eq '(brew|apt|apt-get|winget|pip|pip3|npm)[[:space:]]+(install|remove|uninstall|upgrade|update)\b'; then
    check "no install/remove/upgrade in ${script##*/}" "no"
  else
    check "no install/remove/upgrade in ${script##*/}" "yes"
  fi
}

run_report_checks "${lab_dir}/examples/detect_pkg_manager.sh"
run_report_checks "${lab_dir}/starter/detect_pkg_manager.sh"
check_read_only "${lab_dir}/examples/detect_pkg_manager.sh"
check_read_only "${lab_dir}/starter/detect_pkg_manager.sh"

echo
echo "${checks} checks, ${failures} failure(s)."
[ "${failures}" -eq 0 ]