Upload 11 files

.dockerignore

@@ -0,0 +1,14 @@
+.git
+.venv
+uv.lock
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.env
+.env.*
+.claude/
+.claude.json
+.DS_Store
+*.zip

.gitignore

@@ -0,0 +1,10 @@
+.venv/
+uv.lock
+__pycache__/
+*.py[cod]
+.env
+.env.*
+.claude/
+.claude.json
+.DS_Store
+*.zip

.python-version

@@ -0,0 +1 @@
+3.12

Dockerfile

@@ -6,35 +6,46 @@ ARG UV_VERSION=0.11.29
 FROM ghcr.io/astral-sh/uv:${UV_VERSION} AS uv
 FROM ghcr.io/coder/code-server:${CODE_SERVER_VERSION}
 
+ARG CLAUDE_CODE_CHANNEL=latest
+
 USER root
 
-# Install a small Python build toolchain, the official Claude Code CLI,
+# Install a small native build toolchain, the official Claude Code CLI,
 # and the official ngrok Agent CLI.
-RUN apt-get update \
-    && DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
+RUN set -eux; \
+    case "${CLAUDE_CODE_CHANNEL}" in latest|stable) ;; *) exit 2 ;; esac; \
+    apt-get update; \
+    DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
        build-essential \
        ca-certificates \
        curl \
+       git \
        jq \
        pkg-config \
        ripgrep \
-       unzip \
-    && install -d -m 0755 /etc/apt/keyrings \
-    && curl -fsSL https://downloads.claude.ai/keys/claude-code.asc \
-       -o /etc/apt/keyrings/claude-code.asc \
-    && printf '%s\n' \
-       'deb [signed-by=/etc/apt/keyrings/claude-code.asc] https://downloads.claude.ai/claude-code/apt/stable stable main' \
-       > /etc/apt/sources.list.d/claude-code.list \
-    && curl -fsSL https://ngrok-agent.s3.amazonaws.com/ngrok.asc \
-       -o /etc/apt/keyrings/ngrok.asc \
-    && printf '%s\n' \
+       unzip; \
+    install -d -m 0755 /etc/apt/keyrings; \
+    curl -fsSL https://downloads.claude.ai/keys/claude-code.asc \
+       -o /etc/apt/keyrings/claude-code.asc; \
+    printf '%s\n' \
+       "deb [signed-by=/etc/apt/keyrings/claude-code.asc] https://downloads.claude.ai/claude-code/apt/${CLAUDE_CODE_CHANNEL} ${CLAUDE_CODE_CHANNEL} main" \
+       > /etc/apt/sources.list.d/claude-code.list; \
+    curl -fsSL https://ngrok-agent.s3.amazonaws.com/ngrok.asc \
+       -o /etc/apt/keyrings/ngrok.asc; \
+    printf '%s\n' \
        'deb [signed-by=/etc/apt/keyrings/ngrok.asc] https://ngrok-agent.s3.amazonaws.com buster main' \
-       > /etc/apt/sources.list.d/ngrok.list \
-    && apt-get update \
-    && DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
+       > /etc/apt/sources.list.d/ngrok.list; \
+    apt-get update; \
+    DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
        claude-code \
-       ngrok \
-    && rm -rf /var/lib/apt/lists/*
+       ngrok; \
+    CLAUDE_BIN="$(command -v claude)"; \
+    test -x "${CLAUDE_BIN}"; \
+    ln -sf "${CLAUDE_BIN}" /usr/local/bin/claude-system; \
+    /usr/local/bin/claude-system --version; \
+    ngrok version; \
+    git --version; \
+    rm -rf /var/lib/apt/lists/*
 
 COPY --from=uv /uv /uvx /usr/local/bin/
 
@@ -48,10 +59,12 @@ ENV HOME=/home/coder \
     PATH="/home/coder/workspace/.venv/bin:/home/coder/.local/bin:${PATH}" \
     PYTHONDONTWRITEBYTECODE=1 \
     PYTHONUNBUFFERED=1 \
-    CS_DISABLE_GETTING_STARTED_OVERRIDE=true
+    CS_DISABLE_GETTING_STARTED_OVERRIDE=true \
+    CLAUDE_SYSTEM_BIN=/usr/local/bin/claude-system \
+    CLAUDE_VSCODE_WRAPPER=/usr/local/bin/claude-vscode-wrapper
 
-# /data is mounted only at runtime on Hugging Face Spaces. Build seed artifacts
-# elsewhere and copy them into the persistent disk from the startup initializer.
+# /data is mounted at runtime. Build all reusable artifacts in the image and
+# restore them into the persistent disk from the startup initializer.
 RUN install -d -o coder -g coder \
        /opt/bootstrap \
        /opt/bootstrap/code-server-user-data \
@@ -60,25 +73,28 @@ RUN install -d -o coder -g coder \
        /opt/uv/python \
        /home/coder/workspace
 
-COPY --chown=coder:coder pyproject.toml /tmp/workspace-deps/pyproject.toml
+COPY --chown=coder:coder pyproject.toml /home/coder/workspace/pyproject.toml
+COPY --chown=coder:coder workspace/README.md /opt/bootstrap/workspace-src/README.md
+COPY --chown=coder:coder workspace.gitignore /opt/bootstrap/workspace.gitignore
 
 USER coder
 
-# Build a relocatable Python 3.12 project environment. It is restored under
-# /data/workspace and exposed through /home/coder/workspace at runtime.
+# Resolve the dependency manifest and build the Python 3.12 environment at the
+# same path it will use at runtime. Archive the environment and preserve the
+# project manifest and lockfile for the candidate workspace.
 RUN set -eux; \
-    cp /tmp/workspace-deps/pyproject.toml /home/coder/workspace/pyproject.toml; \
     cd /home/coder/workspace; \
     uv python install 3.12; \
     uv sync --python 3.12 --no-install-project; \
-    cp uv.lock /opt/bootstrap/uv.lock; \
+    cp pyproject.toml uv.lock /opt/bootstrap/workspace-src/; \
+    cat pyproject.toml uv.lock | sha256sum | awk '{print $1}' \
+      | tee /opt/bootstrap/venv.id > .venv/.hf-bootstrap-id; \
     tar -C /home/coder/workspace -czf /opt/bootstrap/venv.tar.gz .venv; \
     cd /; \
     uv cache clean; \
-    rm -rf /home/coder/workspace /tmp/workspace-deps
+    rm -rf /home/coder/workspace
 
 # Install and verify the requested extensions into image-side bootstrap paths.
-# Runtime initialization copies them to /data and repairs the registry if needed.
 RUN set -eux; \
     code-server \
       --user-data-dir /opt/bootstrap/code-server-user-data \
@@ -93,32 +109,22 @@ RUN set -eux; \
     grep -Fxi 'ms-python.python' /tmp/preinstalled-extensions.txt; \
     rm -f /tmp/preinstalled-extensions.txt
 
-# Seed the Space repository into the persistent workspace. Include the generated
-# uv.lock even when it is excluded from the repository build context.
-COPY --chown=coder:coder . /opt/bootstrap/workspace-src/
-
-RUN set -eux; \
-    cp /opt/bootstrap/uv.lock /opt/bootstrap/workspace-src/uv.lock; \
-    tar -C /opt/bootstrap/workspace-src -czf /opt/bootstrap/workspace-seed.tar.gz .; \
-    rm -rf /opt/bootstrap/workspace-src
-
 USER root
 
 COPY --chown=root:root --chmod=0755 scripts/10-init-persistent-data.sh \
      /usr/local/bin/init-persistent-data
 COPY --chown=root:root --chmod=0755 scripts/start-code-server.sh \
      /usr/local/bin/start-code-server
+COPY --chown=root:root --chmod=0755 scripts/claude-vscode-wrapper.sh \
+     /usr/local/bin/claude-vscode-wrapper
 
-# These locations exist only after the HF persistent disk is mounted.
 ENV UV_CACHE_DIR=/data/cache/uv \
     HF_HOME=/data/cache/huggingface \
     CLAUDE_CONFIG_DIR=/data/claude
 
 USER coder
 
-# The workspace symlink is created at runtime, so the OCI process must begin in
-# an image-resident directory. The wrapper changes into the workspace before
-# launching code-server.
+# The workspace symlink is created after the HF persistent disk is mounted.
 WORKDIR /home/coder
 
 EXPOSE 7860

README.md

@@ -1,117 +1,15 @@
 ---
-title: Seb Test Space
-emoji: 🧪
-colorFrom: indigo
-colorTo: blue
+title: Coding Interview Workspace
+emoji: 💻
+colorFrom: blue
+colorTo: indigo
 sdk: docker
 app_port: 7860
 pinned: false
 ---
 
-# code-server POC
+# Coding Interview Workspace
 
-Open the Space through its direct `https://<space-subdomain>.hf.space` URL rather than the embedded App tab.
+Open the application using the URL and password supplied by your interviewer.
 
-## Space secrets
-
-Required:
-
-- `PASSWORD` — code-server web-login password
-
-Optional:
-
-- `NGROK_AUTHTOKEN` — authenticates the ngrok agent
-- `OPENAI_API_KEY` — used by the OpenAI Python SDK
-- `ANTHROPIC_API_KEY` — used by the Anthropic Python SDK
-
-For Claude Code subscription authentication, initially omit `ANTHROPIC_API_KEY` and run:
-
-```bash
-claude
-```
-
-## Runtime layout
-
-- Physical persistent workspace: `/data/workspace`
-- IDE-visible workspace: `/home/coder/workspace`
-- Python 3.12 environment: `/home/coder/workspace/.venv`
-- code-server user data: `/data/code-server/user-data`
-- code-server extensions: `/data/code-server/extensions`
-- Claude Code configuration: `/data/claude`
-- ngrok configuration: `/data/ngrok`
-
-The startup wrapper initializes these paths before code-server starts, changes into `/home/coder/workspace`, and opens that directory as the default folder.
-
-## Expected startup log
-
-```text
-[hf-code-server-init] Workspace ready: /home/coder/workspace -> /data/workspace
-[hf-code-server-init] Python ready: Python 3.12.x
-[hf-code-server-init] Extensions ready: Anthropic.claude-code ms-python.python ...
-```
-
-## Verify from the integrated terminal
-
-```bash
-pwd
-readlink -f /home/coder/workspace
-python --version
-python -c "import anthropic, fastapi, openai; print('imports OK')"
-
-code-server \
-  --user-data-dir /data/code-server/user-data \
-  --extensions-dir /data/code-server/extensions \
-  --list-extensions
-```
-
-Expected essentials:
-
-```text
-/home/coder/workspace
-/data/workspace
-Python 3.12.x
-Anthropic.claude-code
-ms-python.python
-```
-
-Dependencies are declared in `pyproject.toml`. After editing it:
-
-```bash
-uv sync
-```
-
-## FastAPI and ngrok
-
-```bash
-uv run uvicorn main:app --host 0.0.0.0 --port 8000 --reload
-```
-
-Authenticated code-server proxy:
-
-```text
-https://<space-subdomain>.hf.space/proxy/8000/
-```
-
-Public ngrok tunnel:
-
-```bash
-ngrok http 8000
-```
-
-## Reset stale POC state
-
-The new initializer should repair the existing disk. To reset only code-server settings and extensions while preserving project files:
-
-```bash
-sudo rm -rf /data/code-server
-```
-
-Then restart the Space.
-
-To discard the workspace and its virtual environment too:
-
-```bash
-sudo rm -rf /data/workspace /data/code-server
-```
-
-Do not run the second command when the workspace contains anything you need.
+Candidate instructions are available as `README.md` in the workspace that opens in the editor.

pyproject.toml

@@ -1,7 +1,11 @@
+# This project is managed with uv.
+# Add a dependency with: uv add <package>
+# Synchronize the environment with: uv sync
+
 [project]
-name = "hf-code-server-poc"
+name = "interview-workspace"
 version = "0.1.0"
-description = "Disposable code-server workspace for Hugging Face Spaces"
+description = "Python environment for the coding interview workspace"
 requires-python = ">=3.12,<3.13"
 dependencies = [
   "anthropic",
@@ -10,6 +14,5 @@ dependencies = [
   "uvicorn[standard]",
 ]
 
-# This is an application workspace, not a package to publish.
 [tool.uv]
 package = false

scripts/10-init-persistent-data.sh

@@ -9,6 +9,8 @@ DATA_ROOT="${DATA_ROOT:-/data}"
 CODER_HOME="${CODER_HOME:-/home/coder}"
 BOOTSTRAP_ROOT="${BOOTSTRAP_ROOT:-/opt/bootstrap}"
 CODE_SERVER_BIN="${CODE_SERVER_BIN:-/usr/bin/code-server}"
+CLAUDE_SYSTEM_BIN="${CLAUDE_SYSTEM_BIN:-/usr/local/bin/claude-system}"
+CLAUDE_VSCODE_WRAPPER="${CLAUDE_VSCODE_WRAPPER:-/usr/local/bin/claude-vscode-wrapper}"
 
 WORKSPACE_DATA="${DATA_ROOT}/workspace"
 WORKSPACE_LINK="${WORKSPACE:-${CODER_HOME}/workspace}"
@@ -53,30 +55,8 @@ do
   ensure_dir "${directory}"
 done
 
-# Add image-seeded files that are missing, but never overwrite work already on
-# the persistent disk. The marker avoids repeating this on normal restarts.
-seed_marker="${WORKSPACE_DATA}/.hf-code-server-seed-v4"
-if [ ! -f "${seed_marker}" ]; then
-  log "Seeding persistent workspace at ${WORKSPACE_DATA}"
-  tar --skip-old-files \
-    -C "${WORKSPACE_DATA}" \
-    -xzf "${BOOTSTRAP_ROOT}/workspace-seed.tar.gz"
-  touch "${seed_marker}"
-fi
-
-# Restore the prebuilt Python 3.12 virtual environment when it is absent or
-# invalid. It was built at /home/coder/workspace/.venv, so script shebangs keep
-# working through the runtime workspace symlink.
-if ! "${WORKSPACE_DATA}/.venv/bin/python" -c \
-  'import sys; raise SystemExit(sys.version_info[:2] != (3, 12))' \
-  >/dev/null 2>&1
-then
-  log "Restoring Python 3.12 virtual environment"
-  rm -rf "${WORKSPACE_DATA}/.venv"
-  tar -C "${WORKSPACE_DATA}" -xzf "${BOOTSTRAP_ROOT}/venv.tar.gz"
-fi
-
-# Make the requested IDE-visible path point to persistent storage.
+# Make the requested editor-visible path point to the candidate's persistent
+# workspace. The directory is created before code-server is launched.
 if [ -L "${WORKSPACE_LINK}" ]; then
   current_target="$(readlink "${WORKSPACE_LINK}" || true)"
   if [ "${current_target}" != "${WORKSPACE_DATA}" ]; then
@@ -93,8 +73,80 @@ if [ ! -L "${WORKSPACE_LINK}" ]; then
   ln -s "${WORKSPACE_DATA}" "${WORKSPACE_LINK}"
 fi
 
-# Seed both the extension payload directory and any user-data metadata created
-# by code-server's installer. Existing persistent files are left untouched.
+# Seed the candidate instructions and uv project metadata on first startup.
+# Existing candidate edits are never overwritten on later restarts or rebuilds.
+for project_file in README.md pyproject.toml uv.lock; do
+  source_file="${BOOTSTRAP_ROOT}/workspace-src/${project_file}"
+  target_file="${WORKSPACE_DATA}/${project_file}"
+
+  if [ ! -e "${target_file}" ]; then
+    cp "${source_file}" "${target_file}"
+  fi
+done
+
+# Restore the prebuilt environment if it is absent, is not Python 3.12, or was
+# built from a different dependency manifest.
+expected_venv_id="$(cat "${BOOTSTRAP_ROOT}/venv.id")"
+actual_venv_id="$(cat "${WORKSPACE_DATA}/.venv/.hf-bootstrap-id" 2>/dev/null || true)"
+
+if ! "${WORKSPACE_DATA}/.venv/bin/python" -c \
+  'import sys; raise SystemExit(sys.version_info[:2] != (3, 12))' \
+  >/dev/null 2>&1 \
+  || [ "${actual_venv_id}" != "${expected_venv_id}" ]
+then
+  log "Restoring Python 3.12 virtual environment"
+  rm -rf "${WORKSPACE_DATA}/.venv"
+  tar -C "${WORKSPACE_DATA}" -xzf "${BOOTSTRAP_ROOT}/venv.tar.gz"
+fi
+
+# Each candidate Space owns one repository. Initialize it once, leave existing
+# history untouched on later restarts, and keep environment artifacts ignored
+# without adding a visible top-level .gitignore file.
+new_repository=0
+if [ ! -d "${WORKSPACE_DATA}/.git" ]; then
+  log "Initializing Git repository"
+  if ! git -C "${WORKSPACE_DATA}" init -b main >/dev/null 2>&1; then
+    git -C "${WORKSPACE_DATA}" init >/dev/null
+    git -C "${WORKSPACE_DATA}" symbolic-ref HEAD refs/heads/main
+  fi
+  new_repository=1
+fi
+
+if ! git -C "${WORKSPACE_DATA}" config --get user.name >/dev/null 2>&1; then
+  git -C "${WORKSPACE_DATA}" config user.name "${GIT_USER_NAME:-Candidate}"
+fi
+
+if ! git -C "${WORKSPACE_DATA}" config --get user.email >/dev/null 2>&1; then
+  git -C "${WORKSPACE_DATA}" config user.email "${GIT_USER_EMAIL:-candidate@localhost}"
+fi
+
+exclude_file="${WORKSPACE_DATA}/.git/info/exclude"
+touch "${exclude_file}"
+
+if [ -f "${BOOTSTRAP_ROOT}/workspace.gitignore" ]; then
+  while IFS= read -r pattern || [ -n "${pattern}" ]; do
+    case "${pattern}" in
+      ''|'#'*) continue ;;
+    esac
+    if ! grep -Fqx -- "${pattern}" "${exclude_file}"; then
+      printf '%s\n' "${pattern}" >> "${exclude_file}"
+    fi
+  done < "${BOOTSTRAP_ROOT}/workspace.gitignore"
+fi
+
+# Commit the supplied instructions and uv project definition as the clean
+# baseline for a fresh repository. Existing history is never rewritten.
+if [ "${new_repository}" -eq 1 ] \
+  || ! git -C "${WORKSPACE_DATA}" rev-parse --verify HEAD >/dev/null 2>&1
+then
+  git -C "${WORKSPACE_DATA}" add README.md pyproject.toml uv.lock
+  if ! git -C "${WORKSPACE_DATA}" diff --cached --quiet; then
+    git -C "${WORKSPACE_DATA}" -c commit.gpgsign=false commit \
+      -m "Initialize Python environment" >/dev/null
+  fi
+fi
+
+# Restore preinstalled extensions and the installer metadata they need.
 if [ -d "${BOOTSTRAP_ROOT}/code-server-user-data" ] \
   && [ -z "$(find "${USER_DATA_DIR}" -mindepth 1 -maxdepth 1 -print -quit)" ]
 then
@@ -118,11 +170,8 @@ has_extension() {
 
 installed_extensions="$(list_extensions)"
 
-# Copying extension directories is usually enough, but an old persistent
-# extension registry can hide them. Let code-server repair its own registry if
-# either required extension is not visible.
 if ! has_extension 'Anthropic.claude-code' || ! has_extension 'ms-python.python'; then
-  log "Repairing required extensions in ${EXTENSIONS_DIR}"
+  log "Repairing required extensions"
   "${CODE_SERVER_BIN}" \
     --user-data-dir "${USER_DATA_DIR}" \
     --extensions-dir "${EXTENSIONS_DIR}" \
@@ -142,6 +191,84 @@ if ! has_extension 'ms-python.python'; then
   exit 1
 fi
 
+patch_claude_extension_binaries() {
+  test -x "${CLAUDE_SYSTEM_BIN}"
+
+  for extension_dir in \
+    "${EXTENSIONS_DIR}"/anthropic.claude-code-* \
+    "${EXTENSIONS_DIR}"/Anthropic.claude-code-*
+  do
+    [ -d "${extension_dir}" ] || continue
+
+    for binary_name in claude claude.real; do
+      bundled_binary="${extension_dir}/resources/native-binary/${binary_name}"
+      if [ ! -e "${bundled_binary}" ] && [ ! -L "${bundled_binary}" ]; then
+        continue
+      fi
+
+      if "${bundled_binary}" --version >/dev/null 2>&1; then
+        continue
+      fi
+
+      log "Replacing incompatible Claude extension binary"
+      rm -f "${bundled_binary}"
+      ln -s "${CLAUDE_SYSTEM_BIN}" "${bundled_binary}"
+      "${bundled_binary}" --version >/dev/null
+    done
+  done
+}
+
+patch_claude_extension_binaries
+
+# Keep editor configuration outside the candidate project. The Python
+# environment and Git metadata stay out of Explorer and search; the visible
+# baseline consists of README.md, pyproject.toml, and uv.lock.
+settings_file="${USER_DATA_DIR}/User/settings.json"
+settings_dir="$(dirname "${settings_file}")"
+mkdir -p "${settings_dir}"
+
+if [ ! -f "${settings_file}" ]; then
+  printf '{}\n' > "${settings_file}"
+fi
+
+if jq -e 'type == "object"' "${settings_file}" >/dev/null 2>&1; then
+  settings_tmp="${settings_file}.tmp.$$"
+  jq \
+    --arg wrapper "${CLAUDE_VSCODE_WRAPPER}" \
+    --arg python "${WORKSPACE_LINK}/.venv/bin/python" \
+    --arg workspace "${WORKSPACE_LINK}" \
+    '. + {
+      "claudeCode.claudeProcessWrapper": $wrapper,
+      "python.defaultInterpreterPath": $python,
+      "python.terminal.activateEnvironment": true,
+      "terminal.integrated.cwd": $workspace,
+      "workbench.startupEditor": "readme",
+      "workbench.browser.enableRemoteProxy": true,
+      "workbench.browser.dataStorage": "workspace",
+      "workbench.browser.openLocalhostLinks": true,
+      "workbench.browser.showInTitleBar": true,
+      "files.exclude": ((."files.exclude" // {}) + {
+        "**/.venv": true,
+        "**/.git": true
+      }),
+      "search.exclude": ((."search.exclude" // {}) + {
+        "**/.venv": true,
+        "**/.git": true
+      })
+    }' \
+    "${settings_file}" > "${settings_tmp}"
+  mv "${settings_tmp}" "${settings_file}"
+else
+  log "WARNING: ${settings_file} is not plain JSON; leaving it unchanged"
+fi
+
+# Verify the Claude wrapper both with and without the extension-injected path.
+test -x "${CLAUDE_VSCODE_WRAPPER}"
+"${CLAUDE_VSCODE_WRAPPER}" --version >/dev/null
+"${CLAUDE_VSCODE_WRAPPER}" \
+  "${EXTENSIONS_DIR}/test/resources/native-binary/claude" \
+  --version >/dev/null
+
 # Persist ngrok's default Linux configuration directory.
 mkdir -p "${CODER_HOME}/.config"
 
@@ -161,11 +288,17 @@ if [ ! -L "${CODER_HOME}/.config/ngrok" ]; then
   ln -s "${NGROK_DIR}" "${CODER_HOME}/.config/ngrok"
 fi
 
-# These checks are fatal because the startup wrapper calls this script directly.
 test -d "${WORKSPACE_LINK}"
-test -x "${WORKSPACE_LINK}/.venv/bin/python"
+test -f "${WORKSPACE_LINK}/README.md"
 test -f "${WORKSPACE_LINK}/pyproject.toml"
+test -f "${WORKSPACE_LINK}/uv.lock"
+test -x "${WORKSPACE_LINK}/.venv/bin/python"
+git -C "${WORKSPACE_DATA}" rev-parse --is-inside-work-tree >/dev/null
 
-log "Workspace ready: ${WORKSPACE_LINK} -> $(readlink -f "${WORKSPACE_LINK}")"
+log "Workspace ready: ${WORKSPACE_LINK}"
+log "Candidate instructions ready: ${WORKSPACE_LINK}/README.md"
+log "uv project ready: ${WORKSPACE_LINK}/pyproject.toml"
 log "Python ready: $("${WORKSPACE_LINK}/.venv/bin/python" --version 2>&1)"
+log "Git ready: $(git -C "${WORKSPACE_DATA}" branch --show-current 2>/dev/null || true)"
+log "Claude CLI ready: $("${CLAUDE_SYSTEM_BIN}" --version 2>&1)"
 log "Extensions ready: $(printf '%s' "${installed_extensions}" | tr '\n' ' ')"

scripts/claude-vscode-wrapper.sh

@@ -0,0 +1,20 @@
+#!/bin/sh
+set -eu
+
+# Claude Code's VS Code extension invokes a configured process wrapper as:
+#   wrapper <bundled-claude-path> <claude-arguments...>
+#
+# The Open VSX linux-x64 package can occasionally contain a native binary that
+# is not runnable on the code-server base image. Drop the extension-injected
+# binary path and launch the separately installed Anthropic CLI instead.
+REAL_CLAUDE="${CLAUDE_SYSTEM_BIN:-/usr/local/bin/claude-system}"
+
+if [ "$#" -gt 0 ]; then
+  case "$1" in
+    */resources/native-binary/claude|*/resources/native-binary/claude.real)
+      shift
+      ;;
+  esac
+fi
+
+exec "${REAL_CLAUDE}" "$@"

scripts/start-code-server.sh

@@ -6,10 +6,10 @@ INIT_BIN="${INIT_BIN:-/usr/local/bin/init-persistent-data}"
 DUMB_INIT_BIN="${DUMB_INIT_BIN:-/usr/bin/dumb-init}"
 CODE_SERVER_BIN="${CODE_SERVER_BIN:-/usr/bin/code-server}"
 
-# Keep the UID-repair behavior used by the official image.
+# Preserve the UID-repair behavior from the official image.
 eval "$("${FIXUID_BIN}" -q)"
 
-# Keep the official image's optional user-renaming behavior.
+# Preserve the official image's optional user-renaming behavior.
 if [ "${DOCKER_USER-}" ]; then
   USER="${DOCKER_USER}"
   export USER
@@ -35,15 +35,15 @@ export CODE_SERVER_EXTENSIONS="${CODE_SERVER_EXTENSIONS:-/data/code-server/exten
 export UV_CACHE_DIR="${UV_CACHE_DIR:-/data/cache/uv}"
 export HF_HOME="${HF_HOME:-/data/cache/huggingface}"
 export CLAUDE_CONFIG_DIR="${CLAUDE_CONFIG_DIR:-/data/claude}"
+export CLAUDE_SYSTEM_BIN="${CLAUDE_SYSTEM_BIN:-/usr/local/bin/claude-system}"
+export CLAUDE_VSCODE_WRAPPER="${CLAUDE_VSCODE_WRAPPER:-/usr/local/bin/claude-vscode-wrapper}"
 
-# Run initialization directly. A broken workspace, virtual environment, or
-# extension install now prevents code-server from starting in a partial state.
 "${INIT_BIN}"
 
-# This makes the code-server process and integrated terminals start from the
-# requested workspace, in addition to passing it as the folder to open.
 cd "${WORKSPACE}"
 
+# --ignore-last-opened makes the command-line folder authoritative instead of
+# restoring an older /home/coder session from persistent editor state.
 exec "${DUMB_INIT_BIN}" "${CODE_SERVER_BIN}" \
   --bind-addr "0.0.0.0:${PORT}" \
   --auth password \
@@ -52,4 +52,5 @@ exec "${DUMB_INIT_BIN}" "${CODE_SERVER_BIN}" \
   --extensions-dir "${CODE_SERVER_EXTENSIONS}" \
   --disable-telemetry \
   --disable-update-check \
+  --ignore-last-opened \
   "${WORKSPACE}"

workspace.gitignore

@@ -0,0 +1,13 @@
+.venv/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+.env
+.env.*
+.claude/
+.claude.json
+.DS_Store

workspace/README.md

@@ -0,0 +1,98 @@
+# Coding Interview
+
+Use the password supplied by your interviewer. Keep your work in the repository already open in the editor:
+
+```text
+/home/coder/workspace
+```
+
+## Python environment
+
+Python 3.12 is ready, and this project uses **uv** for dependency and environment management:
+
+- `pyproject.toml` lists the direct dependencies available for the exercise.
+- `uv.lock` records the exact resolved dependency versions.
+- `.venv` contains the active virtual environment.
+
+Useful checks:
+
+```bash
+pwd
+python --version
+uv --version
+uv tree
+git status
+```
+
+Add a dependency with:
+
+```bash
+uv add <package>
+```
+
+After editing `pyproject.toml` manually, synchronize the environment with:
+
+```bash
+uv sync
+```
+
+## Run and preview a FastAPI app
+
+Assuming the FastAPI application is exposed as `app` in `main.py`, start it in a terminal:
+
+```bash
+uv run uvicorn main:app --host 127.0.0.1 --port 8000 --reload
+```
+
+The first choice is to view Swagger UI inside the editor:
+
+1. Open the Command Palette with **Ctrl/Cmd+Shift+P**.
+2. Run **Browser: Open Integrated Browser**. In some editor versions, the command may be named **Simple Browser: Show**.
+3. Open:
+
+   ```text
+   http://127.0.0.1:8000/docs
+   ```
+
+ReDoc is available at:
+
+```text
+http://127.0.0.1:8000/redoc
+```
+
+If the integrated browser does not open the local address, open the current code-server URL in a normal browser tab and append:
+
+```text
+/proxy/8000/docs
+```
+
+## Optional: expose the API with ngrok
+
+Use ngrok only when a service outside the editor must reach your API, such as a webhook provider or an external API client.
+
+Keep Uvicorn running, open a second terminal, and run:
+
+```bash
+ngrok http 8000
+```
+
+ngrok prints a public HTTPS URL. Append `/docs` to that URL to open Swagger UI, for example:
+
+```text
+https://<generated-address>.ngrok.app/docs
+```
+
+If ngrok asks for authentication and an authtoken was supplied for the interview, configure it once and retry:
+
+```bash
+ngrok config add-authtoken <token>
+ngrok http 8000
+```
+
+The generated URL is publicly reachable. Do not expose credentials, environment variables, or sensitive data, and stop the tunnel with **Ctrl+C** when it is no longer needed.
+
+## Source control and tools
+
+The workspace is already a Git repository on the `main` branch. Make commits at useful milestones and do not commit credentials or access tokens.
+
+Claude Code is available when the interview task calls for it.