214 lines
8.5 KiB
Docker
214 lines
8.5 KiB
Docker
FROM debian:bookworm-slim
|
|
|
|
RUN apt-get update && apt-get install -y --no-install-recommends \
|
|
curl \
|
|
ca-certificates \
|
|
git \
|
|
iptables \
|
|
gosu \
|
|
sudo \
|
|
unzip \
|
|
# Rust native build deps (for cargo check)
|
|
pkg-config \
|
|
cmake \
|
|
clang \
|
|
mold \
|
|
libtool \
|
|
libssl-dev \
|
|
libxml2-dev \
|
|
libxmlsec1-dev \
|
|
libxslt1-dev \
|
|
libffi-dev \
|
|
zlib1g-dev \
|
|
libcurl4-openssl-dev \
|
|
libclang-dev \
|
|
libkrb5-dev \
|
|
libsasl2-dev \
|
|
# PostgreSQL (for local DB during development)
|
|
postgresql \
|
|
postgresql-client \
|
|
# Node.js 22 (for npm run check / frontend dev)
|
|
&& curl -fsSL https://deb.nodesource.com/setup_22.x | bash - \
|
|
&& apt-get install -y --no-install-recommends nodejs \
|
|
&& rm -rf /var/lib/apt/lists/* \
|
|
&& echo "ALL ALL=(ALL) NOPASSWD: ALL" > /etc/sudoers.d/sandbox \
|
|
&& chmod 0440 /etc/sudoers.d/sandbox \
|
|
&& chmod 666 /etc/passwd /etc/group /etc/shadow
|
|
|
|
# Install Rust via rustup (stable, minimal profile)
|
|
ENV RUSTUP_HOME=/opt/rustup CARGO_HOME=/opt/cargo
|
|
RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | \
|
|
sh -s -- -y --default-toolchain stable --profile minimal && \
|
|
chmod -R a+rwX /opt/rustup /opt/cargo && \
|
|
ln -s /opt/cargo/bin/* /usr/local/bin/
|
|
|
|
# Install sqlx-cli (for database migrations) and cargo-watch (for auto-reload)
|
|
RUN cargo install sqlx-cli --no-default-features --features native-tls,postgres && \
|
|
cargo install cargo-watch && \
|
|
ln -sf /opt/cargo/bin/sqlx /usr/local/bin/sqlx && \
|
|
ln -sf /opt/cargo/bin/cargo-watch /usr/local/bin/cargo-watch && \
|
|
chmod -R a+rwX /opt/cargo
|
|
|
|
# Embed network init script (sets up iptables firewall, then drops privileges)
|
|
RUN cat <<'SCRIPT' > /usr/local/bin/network-init.sh
|
|
#!/bin/bash
|
|
set -euo pipefail
|
|
|
|
if [ -n "${WM_PROXY_HOST:-}" ] && [ -n "${WM_PROXY_PORT:-}" ]; then
|
|
# Resolve hostnames to ALL IPs (multi-A records, round-robin DNS)
|
|
PROXY_IPS=$(getent ahostsv4 "$WM_PROXY_HOST" | awk '{print $1}' | sort -u)
|
|
RPC_HOST="${WM_RPC_HOST:-$WM_PROXY_HOST}"
|
|
RPC_IPS=$(getent ahostsv4 "$RPC_HOST" | awk '{print $1}' | sort -u)
|
|
|
|
if [ -z "$PROXY_IPS" ] || [ -z "$RPC_IPS" ]; then
|
|
echo "network-init: failed to resolve proxy/RPC host" >&2
|
|
exit 1
|
|
fi
|
|
|
|
# IPv4: default deny outbound
|
|
iptables -P OUTPUT DROP
|
|
iptables -A OUTPUT -o lo -j ACCEPT
|
|
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
|
|
|
|
# Allow DNS (UDP/TCP 53) to configured nameservers.
|
|
# Without this, any hostname resolution hangs until timeout.
|
|
if [ -f /etc/resolv.conf ]; then
|
|
grep '^nameserver' /etc/resolv.conf | awk '{print $2}' | while read -r ns; do
|
|
iptables -A OUTPUT -d "$ns" -p udp --dport 53 -j ACCEPT
|
|
iptables -A OUTPUT -d "$ns" -p tcp --dport 53 -j ACCEPT
|
|
done
|
|
fi
|
|
|
|
# Allow ALL resolved proxy IPs (handles multi-A DNS)
|
|
for ip in $PROXY_IPS; do
|
|
iptables -A OUTPUT -d "$ip" -p tcp --dport "$WM_PROXY_PORT" -j ACCEPT
|
|
done
|
|
|
|
# Allow ALL resolved RPC IPs
|
|
if [ -n "${WM_RPC_PORT:-}" ]; then
|
|
for ip in $RPC_IPS; do
|
|
iptables -A OUTPUT -d "$ip" -p tcp --dport "$WM_RPC_PORT" -j ACCEPT
|
|
done
|
|
fi
|
|
|
|
# Reject (not drop) everything else to fail fast instead of hanging
|
|
iptables -A OUTPUT -j REJECT
|
|
|
|
# IPv6: block entirely to prevent leaks (fail closed)
|
|
if ip6tables -L -n >/dev/null 2>&1; then
|
|
ip6tables -P OUTPUT DROP
|
|
ip6tables -A OUTPUT -o lo -j ACCEPT
|
|
ip6tables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
|
|
ip6tables -A OUTPUT -j REJECT
|
|
else
|
|
# If ip6tables unavailable, disable IPv6 via sysctl as fallback
|
|
if ! sysctl -w net.ipv6.conf.all.disable_ipv6=1 2>/dev/null; then
|
|
echo "network-init: failed to block IPv6 (neither ip6tables nor sysctl available)" >&2
|
|
exit 1
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# Add sandbox user to passwd so sudo works with arbitrary UIDs.
|
|
if ! getent passwd "${WM_TARGET_UID}" >/dev/null 2>&1; then
|
|
echo "sandbox:x:${WM_TARGET_UID}:${WM_TARGET_GID}:sandbox:/tmp:/bin/sh" >> /etc/passwd
|
|
echo "sandbox:x:${WM_TARGET_GID}:" >> /etc/group 2>/dev/null || true
|
|
fi
|
|
|
|
# Fix PTY ownership so the unprivileged user can read/write the terminal.
|
|
# Docker allocates the PTY as root; after gosu drops privileges, the user
|
|
# has no access to /dev/pts/0 unless we transfer ownership.
|
|
if [ -t 0 ]; then
|
|
chown "${WM_TARGET_UID}:${WM_TARGET_GID}" "$(tty)"
|
|
fi
|
|
|
|
# Drop privileges and exec the user command.
|
|
# gosu resets HOME via getpwuid() which returns "/" for UIDs not in /etc/passwd.
|
|
# Preserve the container's HOME=/tmp so agents find their config dirs.
|
|
exec gosu "${WM_TARGET_UID}:${WM_TARGET_GID}" env HOME=/tmp "$@"
|
|
SCRIPT
|
|
RUN chmod +x /usr/local/bin/network-init.sh
|
|
|
|
# Install workmux (needed for sandbox RPC)
|
|
RUN curl -fsSL https://raw.githubusercontent.com/raine/workmux/main/scripts/install.sh | bash
|
|
|
|
# --- claude agent ---
|
|
# Install Claude Code, then move to a globally accessible path so the binary
|
|
# is reachable when running as an arbitrary non-root UID (--user uid:gid).
|
|
RUN curl -fsSL https://claude.ai/install.sh | bash && \
|
|
target="$(readlink -f /root/.local/bin/claude)" && \
|
|
mv /root/.local/share/claude /opt/claude && \
|
|
ln -s "/opt/claude/versions/$(basename "$target")" /usr/local/bin/claude && \
|
|
# Claude Code checks $HOME/.local/bin/claude when installMethod is "native".
|
|
# Container sets HOME=/tmp, so place a symlink to suppress the warning.
|
|
mkdir -p /tmp/.local/bin && \
|
|
ln -s /usr/local/bin/claude /tmp/.local/bin/claude && \
|
|
chmod 777 /tmp/.local
|
|
|
|
# --- codex agent ---
|
|
RUN npm i -g @openai/codex
|
|
|
|
# ── Install bun (globally accessible) ─────────────────────────────────────────
|
|
ENV BUN_INSTALL=/opt/bun
|
|
RUN curl -fsSL https://bun.sh/install | bash \
|
|
&& ln -s /opt/bun/bin/bun /usr/local/bin/bun \
|
|
&& ln -s /opt/bun/bin/bunx /usr/local/bin/bunx \
|
|
&& chmod -R a+rX /opt/bun
|
|
|
|
# ── Playwright + Chromium (for screenshots) ──────────────────────────────────
|
|
ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright-browsers
|
|
RUN bun add -g @playwright/test \
|
|
&& bunx playwright install chromium --with-deps \
|
|
&& chmod -R a+rwX /opt/bun/install/ \
|
|
&& rm -rf /tmp/bunx-* \
|
|
&& chmod -R a+rX /opt/playwright-browsers \
|
|
&& rm -rf /var/lib/apt/lists/*
|
|
|
|
# ── AWS CLI (for S3-compatible uploads to R2) ─────────────────────────────────
|
|
RUN curl -fsSL "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o /tmp/awscliv2.zip \
|
|
&& unzip -q /tmp/awscliv2.zip -d /tmp \
|
|
&& /tmp/aws/install \
|
|
&& rm -rf /tmp/aws /tmp/awscliv2.zip
|
|
|
|
# Pre-configure AWS CLI for R2: credentials come from env vars automatically
|
|
# (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY), just set the defaults.
|
|
ENV AWS_DEFAULT_REGION=auto
|
|
|
|
# Entrypoint that registers the dynamic UID in /etc/passwd so sudo works.
|
|
# workmux passes --user UID:GID directly, bypassing network-init.sh.
|
|
RUN cat <<'ENTRY' > /usr/local/bin/entrypoint.sh
|
|
#!/bin/sh
|
|
if ! getent passwd "$(id -u)" >/dev/null 2>&1; then
|
|
echo "sandbox:x:$(id -u):$(id -g):sandbox:/tmp:/bin/sh" >> /etc/passwd
|
|
fi
|
|
if ! getent group "$(id -g)" >/dev/null 2>&1; then
|
|
echo "sandbox:x:$(id -g):" >> /etc/group
|
|
fi
|
|
if ! grep -q "^sandbox:" /etc/shadow 2>/dev/null; then
|
|
echo "sandbox:*:19000:0:99999:7:::" >> /etc/shadow
|
|
fi
|
|
|
|
# Start PostgreSQL (unix socket in /tmp, owned by postgres user)
|
|
mkdir -p /tmp/pgdata && sudo chown postgres:postgres /tmp/pgdata
|
|
if [ ! -f /tmp/pgdata/PG_VERSION ]; then
|
|
sudo -u postgres /usr/lib/postgresql/15/bin/initdb -D /tmp/pgdata --auth=trust
|
|
fi
|
|
sudo -u postgres /usr/lib/postgresql/15/bin/pg_ctl -D /tmp/pgdata -l /tmp/pg.log start -o "-k /tmp"
|
|
sudo -u postgres psql -h /tmp -c "CREATE ROLE sandbox SUPERUSER LOGIN" 2>/dev/null || true
|
|
sudo -u postgres createdb -h /tmp windmill 2>/dev/null || true
|
|
|
|
# Run database migrations so sqlx compile-time checks work
|
|
if [ -d "$PWD/backend/migrations" ]; then
|
|
DATABASE_URL="postgres://sandbox@localhost/windmill?host=/tmp" \
|
|
sqlx migrate run --source "$PWD/backend/migrations" 2>/dev/null || true
|
|
fi
|
|
|
|
# Install frontend dependencies and generate backend client
|
|
if [ -d "$PWD/frontend" ]; then
|
|
(cd "$PWD/frontend" && npm install && npm run generate-backend-client) 2>/dev/null || true
|
|
fi
|
|
|
|
exec "$@"
|
|
ENTRY
|
|
RUN chmod +x /usr/local/bin/entrypoint.sh
|
|
ENTRYPOINT ["/usr/local/bin/entrypoint.sh"] |