Hands-on lab — Day 32: Remotes and GitHub

#!/usr/bin/env bash
# Day 032 lab — Remotes Without a Network (completed reference implementation).
#
# Demonstrates the full clone / push / fetch / pull cycle using a LOCAL bare
# repository as the remote. No GitHub account, no network, no authentication:
# the "remote" is just a folder on your own disk. Every git command here is
# the SAME one you would run against a real hosting platform — only the
# address is a path instead of a web URL.
#
# Run from the lab directory:
#   bash examples/remote_demo.sh
set -euo pipefail

# --- A private scratch workspace, cleaned up automatically on exit ----------
workspace="$(mktemp -d "${TMPDIR:-/tmp}/day32-remote.XXXXXX")"
cleanup() { rm -rf "${workspace}"; }
trap cleanup EXIT

# A local identity JUST for this demo, so commits work without touching your
# global git config. -c passes config to a single command only.
id=(-c user.name="Day 32 Learner" -c user.email="learner@example.invalid")

origin="${workspace}/origin.git"     # the "remote": a bare repository
repo_a="${workspace}/repo-a"         # first working copy
repo_b="${workspace}/repo-b"         # second working copy (a clone)

section() { printf '\n=== %s ===\n' "$1"; }

section "1. Create a bare repository to act as the remote (origin)"
git init --bare -b main "${origin}" >/dev/null
echo "Created bare remote at: ${origin}"
echo "A bare repo stores history but has NO working files — exactly like a server."

section "2. Create a working repository and register the remote"
git init -b main "${repo_a}" >/dev/null
cd "${repo_a}"
echo "# Shared Notes" > README.md
git "${id[@]}" add README.md
git "${id[@]}" commit -q -m "Initial commit"
git remote add origin "${origin}"
echo "git remote -v:"
git remote -v

section "3. Push the first commit and set the upstream"
git "${id[@]}" push -u origin main
echo "git branch -vv (note 'origin/main' upstream):"
git branch -vv

section "4. Clone the remote into a SECOND working copy"
git clone "${origin}" "${repo_b}" 2>&1 | sed 's/^/  /'
echo "Files in the clone:"
ls -1 "${repo_b}"

section "5. Make a commit in the clone and push it up"
cd "${repo_b}"
echo "line added from repo-b" > shared.txt
git "${id[@]}" add shared.txt
git "${id[@]}" commit -q -m "Add shared.txt from the second copy"
git "${id[@]}" push origin main
echo "repo-b pushed a new commit to origin."

section "6. Back in the first copy: fetch shows what changed, pull integrates it"
cd "${repo_a}"
git fetch origin >/dev/null 2>&1
echo "git branch -vv after fetch (repo-a is now 'behind'):"
git branch -vv
echo
echo "git pull (fetch + merge):"
git "${id[@]}" pull origin main 2>&1 | sed 's/^/  /'
echo "Files in repo-a now include the file pushed from repo-b:"
ls -1

section "7. Confirm both working copies and the remote agree"
echo "repo-a log:"
git log --oneline
echo "shared.txt present in repo-a: $([ -f shared.txt ] && echo yes || echo no)"

echo
echo "=== Done: a change travelled repo-b -> origin -> repo-a, with no network. ==="

lesson_id: D032
day: 32
kind: command-line-inspection
languages: [bash]
setup_commands:
  - cd labs/sections/computing-foundations/day-032-remotes-and-github
run_commands:
  - bash examples/remote_demo.sh
  - bash starter/remote_demo.sh
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - 'git checkout -- starter/remote_demo.sh  # optional: reset your work (temp dirs auto-clean)'
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 → 12 checks, 0 failure(s)'

# Dependencies — Day 032 lab

**Only Git and a POSIX shell.** This lab has zero installable dependencies
and needs no account, no network, and no API key:

- `git` (2.28 or newer recommended, for `git init -b main`; an older-Git
  fallback is documented in `troubleshooting.md`).
- `bash` ≥ 3.2 (preinstalled on macOS and every mainstream Linux distro).
- Standard OS utilities: `mktemp`, `rm`, `ls`, `sed`, `grep` — all part of
  the base system.

## Do I need a GitHub account?

**No.** The whole point of this lab is to teach remotes *truthfully without a
network*: the "remote" is a **bare repository** in a temporary folder on your
own disk, and every `git` command is exactly the one you would run against a
hosting platform.

A **real** push to a hosting platform additionally needs two things this lab
deliberately does not require, both covered conceptually in the lesson:

1. **An account** on a platform (such as GitHub, GitLab, or Bitbucket).
2. **Authentication** — either an HTTPS **personal access token** or an
   **SSH key pair**. You never use your account password directly, and you
   never put a token or password in the remote URL.

When you are ready to try a real remote, create a repository on the platform,
copy the address it gives you, and run the same `git remote add` / `git push`
commands from this lab against that address instead of a folder path.

#!/usr/bin/env bash
# Day 032 lab — Remotes Without a Network (STARTER).
#
# This starter sets up the workspace for you. Your job is to complete the five
# numbered exercises below by replacing each `REPLACE_ME` call with the exact
# git command named in the comment above it. The completed reference version
# is in examples/remote_demo.sh — try this yourself first, then compare.
#
# Run from the lab directory:
#   bash starter/remote_demo.sh
#
# Note: we deliberately do NOT use `set -e` here, so that an unfinished
# exercise reports itself instead of stopping the whole script.
set -uo pipefail

# Absolute path to this script, captured before we change directories, so the
# completion check at the end can scan the file wherever it is run from.
self="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/$(basename "${BASH_SOURCE[0]}")"

# --- A private scratch workspace, cleaned up automatically on exit ----------
workspace="$(mktemp -d "${TMPDIR:-/tmp}/day32-remote.XXXXXX")"
cleanup() { rm -rf "${workspace}"; }
trap cleanup EXIT

# A local identity JUST for this demo, so commits work without touching your
# global git config.
id=(-c user.name="Day 32 Learner" -c user.email="learner@example.invalid")

origin="${workspace}/origin.git"     # the "remote": a bare repository
repo_a="${workspace}/repo-a"         # first working copy
repo_b="${workspace}/repo-b"         # second working copy (a clone)

# When an exercise is still unfinished, this stand-in prints a reminder
# instead of running a command. Replace each REPLACE_ME line with real git.
REPLACE_ME() { echo "  [ ] Exercise not completed yet — replace this line (see the comment above)."; }

section() { printf '\n=== %s ===\n' "$1"; }

# --- Given for you: a bare remote and a first working repo with one commit ---
git init --bare -b main "${origin}" >/dev/null
git init -b main "${repo_a}" >/dev/null
cd "${repo_a}"
echo "# Shared Notes" > README.md
git "${id[@]}" add README.md
git "${id[@]}" commit -q -m "Initial commit"

section "Exercise 1 — register the bare repo as a remote named 'origin'"
# Replace the next line with:
#   git remote add origin "${origin}"
REPLACE_ME
echo "Check it with:"; git remote -v

section "Exercise 2 — push the first commit and set the upstream"
# Replace the next line with:
#   git "${id[@]}" push -u origin main
REPLACE_ME
echo "Check the upstream with:"; git branch -vv

section "Exercise 3 — clone the remote into a second working copy"
# Replace the next line with:
#   git clone "${origin}" "${repo_b}"
REPLACE_ME
echo "If it worked, the clone contains:"; ls -1 "${repo_b}" 2>/dev/null || echo "  (no clone yet)"

section "Exercise 4 — in the clone, make a commit and push it up"
if [ -d "${repo_b}" ]; then
  cd "${repo_b}"
  echo "line added from repo-b" > shared.txt
  git "${id[@]}" add shared.txt
  git "${id[@]}" commit -q -m "Add shared.txt from the second copy"
  # Replace the next line with:
  #   git "${id[@]}" push origin main
  REPLACE_ME
else
  echo "  (skipped — finish Exercise 3 first so the clone exists)"
fi

section "Exercise 5 — back in the first copy, pull the new commit"
cd "${repo_a}"
# Replace the next line with:
#   git "${id[@]}" pull origin main
REPLACE_ME
echo "Files in repo-a now:"; ls -1

# --- Completion check --------------------------------------------------------
echo
if grep -q "REPLACE_ME$" "${self}" 2>/dev/null; then
  echo "Some exercises are still unfinished — search this file for REPLACE_ME."
else
  echo "All five exercises look complete. Compare with examples/remote_demo.sh."
fi

# Remotes worksheet — Day 032

Fill this in as you work through `starter/remote_demo.sh` (or the commands in
the lesson's hands-on section). Record what you actually ran and saw.

## 1. Your remote

- **Remote name** (the label you gave it, e.g. `origin`): ______________________
- **Remote path** (the bare repository's folder path): ________________________
- Paste the output of `git remote -v`:

```text
(paste here)
```

## 2. The push you performed

- Exact command you ran to push and set the upstream:

```text
(e.g. git push -u origin main)
```

- What the push printed (the `[new branch]` / upstream line):

```text
(paste here)
```

- Paste `git branch -vv` after the push (it should show `[origin/main]`):

```text
(paste here)
```

## 3. The pull you performed

- Exact command you ran to pull:

```text
(e.g. git pull origin main)
```

- What the pull printed (look for `Fast-forward` and the changed file):

```text
(paste here)
```

## 4. How the change travelled

In your own words (3–5 sentences), trace the journey of the single change
`shared.txt`: where it was created, which command sent it up to the shared
bare repository, and which command brought it down into the other copy.

```text
(write here)
```

## 5. Why a push can be rejected

In 4–6 sentences, explain to a beginner why Git refuses a push when the
remote already has commits you do not, and what the safe fix is. Use the
shared-drawer analogy from the lesson, or one of your own.

```text
(write here)
```

#!/usr/bin/env bash
# Tests for the Day 032 lab. Run from the lab directory:
#   bash tests/run_tests.sh
#
# Verifies the full local-remote cycle with NO network: a push to a bare
# repository succeeds, a second clone receives the history, and a change
# pushed from one clone propagates to the other via pull. Also runs the
# shipped reference script and checks its output for the same evidence.
# Exits 0 on success, non-zero on any failure (CI-friendly).
set -uo pipefail

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
}

id=(-c user.name="Day 32 Test" -c user.email="test@example.invalid")

# --------------------------------------------------------------------------
# Part 1: an independent local-remote cycle, asserted directly.
# --------------------------------------------------------------------------
echo "Part 1: independent push / clone / pull cycle (no network) ..."
ws="$(mktemp -d "${TMPDIR:-/tmp}/day32-test.XXXXXX")"
trap 'rm -rf "${ws}"' EXIT

origin="${ws}/origin.git"
repo_a="${ws}/repo-a"
repo_b="${ws}/repo-b"

git init --bare -b main "${origin}" >/dev/null 2>&1
git init -b main "${repo_a}" >/dev/null 2>&1
(
  cd "${repo_a}"
  echo "# Shared Notes" > README.md
  git "${id[@]}" add README.md
  git "${id[@]}" commit -q -m "Initial commit"
  git remote add origin "${origin}"
  git "${id[@]}" push -u origin main
) >/dev/null 2>&1
push_rc=$?
check "push to the bare remote succeeds (exit 0)" "$([ ${push_rc} -eq 0 ] && echo yes || echo no)"

# The remote (a bare repo) now has a main branch pointing at a commit.
if git --git-dir="${origin}" rev-parse --verify -q main >/dev/null; then
  check "remote now has a 'main' branch" "yes"
else
  check "remote now has a 'main' branch" "no"
fi

# A second clone must receive the pushed history.
git clone "${origin}" "${repo_b}" >/dev/null 2>&1
if [ -f "${repo_b}/README.md" ]; then
  check "second clone receives the pushed file (README.md)" "yes"
else
  check "second clone receives the pushed file (README.md)" "no"
fi

# Commit a change in the clone and push it.
(
  cd "${repo_b}"
  echo "line from repo-b" > shared.txt
  git "${id[@]}" add shared.txt
  git "${id[@]}" commit -q -m "Add shared.txt"
  git "${id[@]}" push origin main
) >/dev/null 2>&1

# Before pull, repo-a must NOT have the file; after pull, it must.
before="absent"; [ -f "${repo_a}/shared.txt" ] && before="present"
( cd "${repo_a}" && git "${id[@]}" pull origin main ) >/dev/null 2>&1
after="absent"; [ -f "${repo_a}/shared.txt" ] && after="present"
if [ "${before}" = "absent" ] && [ "${after}" = "present" ]; then
  check "a change propagates via pull (absent before, present after)" "yes"
else
  check "a change propagates via pull (absent before, present after)" "no"
fi

# The upstream tracking must be set on repo-a's main.
if ( cd "${repo_a}" && git rev-parse --abbrev-ref --symbolic-full-name '@{u}' 2>/dev/null | grep -q '^origin/main$' ); then
  check "repo-a's main tracks origin/main (upstream set)" "yes"
else
  check "repo-a's main tracks origin/main (upstream set)" "no"
fi

# No remote was a network URL — all paths are local folders.
url="$(cd "${repo_a}" && git remote get-url origin)"
case "${url}" in
  http://*|https://*|git@*) check "remote is a LOCAL path, not a network URL" "no" ;;
  *) check "remote is a LOCAL path, not a network URL" "yes" ;;
esac

# --------------------------------------------------------------------------
# Part 2: the shipped reference script runs and shows the same evidence.
# --------------------------------------------------------------------------
echo "Part 2: examples/remote_demo.sh produces the expected evidence ..."
if out="$(bash "${lab_dir}/examples/remote_demo.sh" 2>&1)"; then
  check "reference script exits successfully" "yes"
else
  check "reference script exits successfully" "no"
fi
echo "${out}" | grep -q '\[new branch\] *main -> main' && check "reference shows the push creating 'main' on the remote" "yes" || check "reference shows the push creating 'main' on the remote" "no"
echo "${out}" | grep -q 'set up to track' && check "reference shows the upstream being set" "yes" || check "reference shows the upstream being set" "no"
echo "${out}" | grep -q 'Fast-forward' && check "reference shows a fast-forward pull" "yes" || check "reference shows a fast-forward pull" "no"
echo "${out}" | grep -q 'shared.txt present in repo-a: yes' && check "reference confirms the change reached repo-a" "yes" || check "reference confirms the change reached repo-a" "no"

# --------------------------------------------------------------------------
# Part 3: the starter runs without error (structure only).
# --------------------------------------------------------------------------
echo "Part 3: starter/remote_demo.sh runs as a skeleton ..."
if bash "${lab_dir}/starter/remote_demo.sh" >/dev/null 2>&1; then
  check "starter script runs without a fatal error" "yes"
else
  check "starter script runs without a fatal error" "no"
fi

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