- clone_repos records `<folder>\tcloning` as each clone begins; triple-c-wip-push skips a folder whose last state is `cloning` while the clone is not done (dry run reports "cloning": true; RepoState/TS carry it, the stop guard lists it as "still cloning — nothing to push" and never asks because of it). - The idle watcher re-checks quiet() after a successful push and goes back to watching if someone came back during it. - The entrypoint installs its stop trap before the idle watcher and the background clone start, so a TERM in between still runs aws_before_stop. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1287 lines
62 KiB
Bash
1287 lines
62 KiB
Bash
#!/bin/bash
|
|
# NOTE: set -e is intentionally omitted. A failing usermod/groupmod must not
|
|
# kill the entire entrypoint — SSH setup, git config, and the final exec
|
|
# must still run so the container is usable even if remapping fails.
|
|
#
|
|
# NOTE: /home/claude is the mount point of the named volume
|
|
# triple-c-home-{projectId}, so the *image's* copy of that directory is
|
|
# seed-only: after a project's first start it is masked permanently. Anything
|
|
# this script writes under /home/claude on **every** start does reach existing
|
|
# projects (that is why the CLAUDE.md, git config and Mission Control skill
|
|
# copies are written here rather than baked into the image). Anything added to
|
|
# /home/claude in the Dockerfile reaches new projects only, forever. Put
|
|
# upgradable content in /usr/local/bin or /opt, or seed it from here.
|
|
# See "Container Lifecycle" in the repo's CLAUDE.md.
|
|
|
|
# ── AWS workspace (TRIPLEC_HOST=aws): project data off the environment ─────
|
|
# On AWS (an ECS Fargate task) there are no bind mounts and no Docker API.
|
|
# Everything project-shaped arrives as env vars injected from the project's
|
|
# Secrets Manager secret (app/src-tauri/src/aws/workspace.rs):
|
|
# TRIPLEC_FILES {"ssh/<file>": base64, "ca/<file>": base64} — decoded here
|
|
# into /tmp/.host-ssh and /tmp/.host-ca, the paths the
|
|
# Docker bind mounts use, so the SSH merge and the CA install
|
|
# below run unchanged;
|
|
# TRIPLEC_REPOS [{"url","branch"|null,"folder"}] — cloned by clone_repos
|
|
# once git credentials and ~/.ssh are in place.
|
|
# Both are unset here, *before* the agent-token block below snapshots the
|
|
# environment for the agent: that snapshot is every terminal's environment on
|
|
# AWS, and the files hold private keys. The repo list is kept only as an
|
|
# unexported shell variable, which no child process inherits.
|
|
#
|
|
# Nothing in this block (or any other aws block) runs without TRIPLEC_HOST=aws;
|
|
# a Docker container sees the same script it always did.
|
|
# >>> aws_env
|
|
triplec_aws=0
|
|
triplec_run_as=claude
|
|
triplec_repos_json=
|
|
# Where Hybrid storage mounts the project's EFS access point.
|
|
triplec_home_mnt=/mnt/triple-c-home
|
|
|
|
# stdin: the TRIPLEC_FILES JSON; $1 the ssh dir, $2 the CA dir. Names are
|
|
# validated (non-empty, no `/`, not `.`/`..`, no NUL) and anything else is
|
|
# refused by name. Files are mode 600 in 700 dirs, root-owned when run as root,
|
|
# as the read-only bind mounts would present them.
|
|
aws_decode_files() {
|
|
python3 -I -c '
|
|
import base64, binascii, json, os, stat, sys
|
|
dirs = {"ssh": sys.argv[1], "ca": sys.argv[2]}
|
|
root = os.geteuid() == 0
|
|
def say(msg):
|
|
print("entrypoint: " + msg, file=sys.stderr)
|
|
try:
|
|
files = json.load(sys.stdin)
|
|
except ValueError:
|
|
say("TRIPLEC_FILES is not valid JSON; no files written")
|
|
sys.exit(1)
|
|
if not isinstance(files, dict):
|
|
say("TRIPLEC_FILES is not a JSON object; no files written")
|
|
sys.exit(1)
|
|
def write(key, value):
|
|
kind, sep, name = key.partition("/")
|
|
if kind not in dirs or not sep or name in ("", ".", "..") or "/" in name or "\0" in name:
|
|
return "not ssh/<name> or ca/<name>"
|
|
name.encode("utf-8") # a lone surrogate cannot name a file
|
|
try:
|
|
data = base64.b64decode(value, validate=True) if isinstance(value, str) else None
|
|
except (binascii.Error, ValueError):
|
|
data = None
|
|
if data is None:
|
|
return "value is not base64"
|
|
d = dirs[kind]
|
|
os.makedirs(d, mode=0o700, exist_ok=True)
|
|
if not stat.S_ISDIR(os.lstat(d).st_mode):
|
|
return "%s is not a directory" % d
|
|
os.chmod(d, 0o700)
|
|
if root:
|
|
os.chown(d, 0, 0)
|
|
fd = os.open(os.path.join(d, name), os.O_WRONLY | os.O_CREAT | os.O_TRUNC | os.O_NOFOLLOW, 0o600)
|
|
with os.fdopen(fd, "wb") as f:
|
|
os.fchmod(f.fileno(), 0o600)
|
|
if root:
|
|
os.fchown(f.fileno(), 0, 0)
|
|
f.write(data)
|
|
return None
|
|
bad = 0
|
|
for key, value in files.items():
|
|
try:
|
|
why = write(key, value)
|
|
except (OSError, UnicodeError, ValueError) as e:
|
|
why = "%s" % (e.strerror if isinstance(e, OSError) and e.strerror else type(e).__name__)
|
|
if why:
|
|
say("refusing file entry %r: %s" % (key, why))
|
|
bad += 1
|
|
sys.exit(1 if bad else 0)
|
|
' "$1" "$2"
|
|
}
|
|
|
|
# Runs a command as the container user (`claude`) when this script is root.
|
|
_triplec_as_user() {
|
|
if [ -n "${triplec_run_as:-}" ] && [ "$(id -u)" = 0 ]; then
|
|
su -s /bin/bash -c '"$@"' -- "$triplec_run_as" _ "$@"
|
|
else
|
|
"$@"
|
|
fi
|
|
}
|
|
|
|
if [ "${TRIPLEC_HOST:-}" = aws ]; then
|
|
triplec_aws=1
|
|
if [ -n "${TRIPLEC_FILES+x}" ]; then
|
|
printf '%s' "$TRIPLEC_FILES" | aws_decode_files /tmp/.host-ssh /tmp/.host-ca \
|
|
|| echo "entrypoint: warning — some TRIPLEC_FILES entries were not written (see above)"
|
|
unset TRIPLEC_FILES
|
|
fi
|
|
triplec_repos_json="${TRIPLEC_REPOS:-}"
|
|
unset TRIPLEC_REPOS
|
|
fi
|
|
# <<< aws_env
|
|
|
|
# ── triple-c-agent token: off the environment before anything else runs ───
|
|
# The agent (started at the very end, see start_agent) authenticates every
|
|
# request with this token, and it runs as root, so the token is effectively
|
|
# root in this container. Given as an env var it would be inherited by every
|
|
# process this script starts (cron, the scheduler, Claude sessions spawned by
|
|
# the agent). So it moves to a root-only file *first* and leaves the
|
|
# environment; the agent reads the file. A `docker exec` session still sees
|
|
# the container's configured env — the local test harness passes it that way
|
|
# and accepts that; on AWS nothing is started by `docker exec`.
|
|
#
|
|
# The agent also takes its exec environment and default working directory
|
|
# from how *it* was started, and execs must see what `docker exec` would: the
|
|
# container's configured env and WorkingDir, not whatever this script has
|
|
# exported or cd'd into by the time it gets to start_agent. So both are
|
|
# snapshotted here, before anything else runs, and the agent is started from
|
|
# the snapshot (`env -i`). The agent drops its own TRIPLEC_AGENT_* settings.
|
|
# >>> agent_token
|
|
agent_cwd=$PWD
|
|
# The token goes on a tmpfs, never the container's writable layer: a file
|
|
# there would persist after stop and ride `docker commit` into the project's
|
|
# snapshot image (the commit's SECRET_ENV_KEYS scrub covers env, not files).
|
|
# /dev/shm is a tmpfs in Docker and on Fargate; anything else is refused.
|
|
if [ -n "${TRIPLEC_AGENT_TOKEN:-}" ]; then
|
|
if [ "$(stat -f -c %T /dev/shm 2>/dev/null)" = tmpfs ]; then
|
|
mkdir -p /dev/shm/triple-c
|
|
chown root:root /dev/shm/triple-c
|
|
chmod 700 /dev/shm/triple-c
|
|
( umask 077; printf '%s' "$TRIPLEC_AGENT_TOKEN" > /dev/shm/triple-c/agent-token )
|
|
export TRIPLEC_AGENT_TOKEN_FILE=/dev/shm/triple-c/agent-token
|
|
else
|
|
echo "triple-c-agent: /dev/shm is not a tmpfs; not writing the token to disk — agent disabled" >&2
|
|
fi
|
|
unset TRIPLEC_AGENT_TOKEN
|
|
fi
|
|
# The exec environment snapshot stays in this script's memory — it holds the
|
|
# container's whole configured env, API keys included, so it must not touch
|
|
# disk either. Minus what bash itself exports (PWD, OLDPWD, SHLVL, `_`):
|
|
# those are this script's, not the container's, and `docker exec` has none.
|
|
agent_env=()
|
|
if [ -n "${TRIPLEC_AGENT_TOKEN_FILE:-}" ]; then
|
|
mapfile -d '' agent_env < <(env -u PWD -u OLDPWD -u SHLVL -u _ -0)
|
|
fi
|
|
# <<< agent_token
|
|
|
|
# ── UID/GID remapping ──────────────────────────────────────────────────────
|
|
# Match the container's claude user to the host user's UID/GID so that
|
|
# bind-mounted files (project dir, docker socket) have correct ownership.
|
|
remap_uid_gid() {
|
|
local target_uid="${HOST_UID}"
|
|
local target_gid="${HOST_GID}"
|
|
local current_uid
|
|
local current_gid
|
|
current_uid=$(id -u claude 2>/dev/null) || { echo "entrypoint: claude user not found"; return 1; }
|
|
current_gid=$(id -g claude 2>/dev/null) || { echo "entrypoint: claude group not found"; return 1; }
|
|
|
|
# ── GID remapping ──
|
|
if [ -n "$target_gid" ] && [ "$target_gid" != "$current_gid" ]; then
|
|
# If another group already holds the target GID, move it out of the way
|
|
local blocking_group
|
|
blocking_group=$(getent group "$target_gid" 2>/dev/null | cut -d: -f1)
|
|
if [ -n "$blocking_group" ] && [ "$blocking_group" != "claude" ]; then
|
|
echo "entrypoint: moving group '$blocking_group' from GID $target_gid to 65533"
|
|
groupmod -g 65533 "$blocking_group" || echo "entrypoint: warning — failed to relocate group '$blocking_group'"
|
|
fi
|
|
groupmod -g "$target_gid" claude \
|
|
&& echo "entrypoint: claude GID -> $target_gid" \
|
|
|| echo "entrypoint: warning — groupmod -g $target_gid claude failed"
|
|
fi
|
|
|
|
# ── UID remapping ──
|
|
if [ -n "$target_uid" ] && [ "$target_uid" != "$current_uid" ]; then
|
|
# If another user already holds the target UID, move it out of the way
|
|
local blocking_user
|
|
blocking_user=$(getent passwd "$target_uid" 2>/dev/null | cut -d: -f1)
|
|
if [ -n "$blocking_user" ] && [ "$blocking_user" != "claude" ]; then
|
|
echo "entrypoint: moving user '$blocking_user' from UID $target_uid to 65533"
|
|
usermod -u 65533 "$blocking_user" || echo "entrypoint: warning — failed to relocate user '$blocking_user'"
|
|
fi
|
|
usermod -u "$target_uid" claude \
|
|
&& echo "entrypoint: claude UID -> $target_uid" \
|
|
|| echo "entrypoint: warning — usermod -u $target_uid claude failed"
|
|
fi
|
|
}
|
|
|
|
# On AWS nothing is bind-mounted and HOST_UID/HOST_GID are never set, so there
|
|
# is nothing to match; skipped outright rather than relying on that.
|
|
[ "$triplec_aws" = 1 ] || remap_uid_gid
|
|
|
|
# Fix ownership of home directory after UID/GID change — only where it is
|
|
# wrong. A blanket `chown -R` rewrites every inode, and where /home/claude is
|
|
# the image's own copy rather than a volume (an ECS/Fargate task) that copies
|
|
# the whole directory up into the writable layer: measured at ~5 minutes on
|
|
# 1 vCPU before the agent could start. `find` only stats. `-h` and find's
|
|
# default no-follow match `chown -R`'s physical walk (it changes a symlink
|
|
# itself, never its target), and like `chown -R` this crosses into the nested
|
|
# ~/.claude volume.
|
|
find /home/claude \( ! -user claude -o ! -group claude \) -exec chown -h claude:claude {} +
|
|
|
|
# ── AWS Hybrid storage: persisted home state (plan ruling P4) ───────────────
|
|
# A Hybrid workspace mounts its EFS access point (POSIX 1000:1000) at
|
|
# /mnt/triple-c-home. Mounting it over /home/claude would hide the image's
|
|
# Claude Code, cargo and uv — EFS has no Docker-volume "copy the image's
|
|
# contents on first mount" — so only user state is persisted, by symlink:
|
|
# ~/.claude, ~/.claude.json and ~/.ssh. On first use each is seeded from the
|
|
# image's copy (or created empty); from then on the persisted copy wins and
|
|
# the fresh image copy every new task starts with is replaced by the link —
|
|
# what a Docker home volume does by masking. Runs before the SSH merge below,
|
|
# so host keys land on EFS, and before anything writes ~/.claude.
|
|
# >>> aws_home
|
|
link_persistent_home() {
|
|
local home="$1" persist="$2" owner="$3" name link target
|
|
if [ ! -d "$persist" ] || [ -L "$persist" ]; then
|
|
echo "entrypoint: warning — Hybrid storage, but $persist is not mounted; home state will not persist"
|
|
return 0
|
|
fi
|
|
# The access point already makes its root 1000:1000; said again here so
|
|
# claude (Claude Code's own atomic saves, write_claude_json) can always
|
|
# create files beside the persisted ones.
|
|
[ -z "$owner" ] || chown "$owner" "$persist" 2>/dev/null
|
|
for name in .claude .claude.json .ssh; do
|
|
link="$home/$name"
|
|
target="$persist/$name"
|
|
if [ -L "$link" ] && [ "$(readlink "$link")" = "$target" ]; then
|
|
continue
|
|
fi
|
|
if [ ! -e "$target" ] && [ ! -L "$target" ]; then
|
|
if [ -e "$link" ] || [ -L "$link" ]; then
|
|
# Staged then renamed: a copy cut short must never look seeded.
|
|
rm -rf "$target.triple-c-seed"
|
|
if ! cp -a "$link" "$target.triple-c-seed" || ! mv "$target.triple-c-seed" "$target"; then
|
|
rm -rf "$target.triple-c-seed"
|
|
echo "entrypoint: warning — could not seed $target; ~/$name stays unpersisted"
|
|
continue
|
|
fi
|
|
elif [ "$name" = .claude.json ]; then
|
|
( umask 077; printf '{}\n' > "$target" ) || {
|
|
echo "entrypoint: warning — could not create $target"; continue; }
|
|
else
|
|
mkdir -m 700 "$target" || {
|
|
echo "entrypoint: warning — could not create $target"; continue; }
|
|
fi
|
|
[ -z "$owner" ] || chown -R "$owner" "$target" 2>/dev/null
|
|
fi
|
|
rm -rf "$link"
|
|
ln -s "$target" "$link" || echo "entrypoint: warning — could not link ~/$name to $target"
|
|
[ -z "$owner" ] || chown -h "$owner" "$link" 2>/dev/null
|
|
done
|
|
echo "entrypoint: Hybrid storage — ~/.claude, ~/.claude.json and ~/.ssh persist on $persist"
|
|
}
|
|
|
|
# The real directory behind a Hybrid ~/.ssh link, printed only when the link
|
|
# is exactly the one link_persistent_home makes and neither it nor the mount
|
|
# is itself a symlink. Root chowns and chmods under the result, and the
|
|
# persisted directory is claude-writable, so root must never be pointed
|
|
# anywhere else by it.
|
|
aws_hybrid_ssh_dir() {
|
|
local home="$1" want="$triplec_home_mnt/.ssh"
|
|
[ "$(readlink "$home/.ssh")" = "$want" ] || return 1
|
|
[ ! -L "$triplec_home_mnt" ] && [ ! -L "$want" ] && [ -d "$want" ] || return 1
|
|
printf '%s' "$want"
|
|
}
|
|
# <<< aws_home
|
|
if [ "$triplec_aws" = 1 ] && [ "${TRIPLEC_STORAGE:-}" = hybrid ]; then
|
|
link_persistent_home /home/claude "$triplec_home_mnt" claude:claude
|
|
fi
|
|
|
|
# ── Corporate CA certificates ───────────────────────────────────────────────
|
|
# The host's CA material is bind-mounted read-only at /tmp/.host-ca. Triple-C
|
|
# mounts a *directory* as-is and a *single file* as /tmp/.host-ca/<name>.crt,
|
|
# so this only ever has to deal with a directory (the file branch below is
|
|
# defensive).
|
|
#
|
|
# Runs before everything that touches the network — the git credential helper,
|
|
# ssh-keyscan, and especially the `claude update` at the bottom of this file,
|
|
# which is itself an HTTPS call that fails behind a TLS-terminating proxy
|
|
# without this.
|
|
#
|
|
# Two things are easy to get wrong here:
|
|
# 1. `update-ca-certificates` globs /usr/local/share/ca-certificates/*.crt
|
|
# case-sensitively. A `.pem` that is merely copied in is ignored in total
|
|
# silence, so certificates are *renamed*, not copied.
|
|
# 2. Chrome/Chromium read neither /etc/ssl nor $SSL_CERT_FILE; they have
|
|
# their own NSS database at ~/.pki/nssdb, seeded below with certutil.
|
|
#
|
|
# NODE_EXTRA_CA_CERTS / REQUESTS_CA_BUNDLE / SSL_CERT_FILE are deliberately NOT
|
|
# exported here. Every terminal is a separate `docker exec`, which inherits the
|
|
# container's configured env and sees nothing this script exported — the same
|
|
# reason $BROWSER had to become an image-level ENV. Triple-C sets them on the
|
|
# container at creation time instead. (They are forwarded into the cron
|
|
# environment file further down, because cron jobs start from a bare env.)
|
|
CA_SRC="/tmp/.host-ca"
|
|
CA_STORE="/usr/local/share/ca-certificates"
|
|
CA_PREFIX="triple-c-"
|
|
CA_BUNDLE="/etc/ssl/certs/ca-certificates.crt"
|
|
CA_STAMP="/var/lib/triple-c/ca.stamp"
|
|
CA_NSSDB="/home/claude/.pki/nssdb"
|
|
|
|
# Mirror of `container_cert_name()` in app/src-tauri/src/docker/ca_certs.rs.
|
|
# The two must agree; the Rust side has the unit tests.
|
|
ca_normalise_name() {
|
|
local name stem
|
|
name=$(printf '%s' "$1" | tr -c 'A-Za-z0-9._-' '_')
|
|
while [ "${name#.}" != "$name" ]; do name="${name#.}"; done
|
|
stem="${name%.*}"
|
|
[ -z "$stem" ] && stem="corporate-ca"
|
|
printf '%s.crt' "$stem"
|
|
}
|
|
|
|
ca_source_files() {
|
|
if [ -d "$CA_SRC" ]; then
|
|
find "$CA_SRC" -maxdepth 1 -type f \
|
|
\( -iname '*.crt' -o -iname '*.pem' -o -iname '*.cer' \
|
|
-o -iname '*.cert' -o -iname '*.ca-bundle' \) 2>/dev/null | sort
|
|
elif [ -f "$CA_SRC" ]; then
|
|
printf '%s\n' "$CA_SRC"
|
|
fi
|
|
}
|
|
|
|
# Seed Chrome/Chromium's NSS database. Tolerant by design: a missing certutil
|
|
# or a broken profile must warn, never fail the container start.
|
|
# ~/.pki lives in the home volume, so this persists once done; the system store
|
|
# lives in the writable layer and is re-applied on every start.
|
|
ca_seed_nssdb() {
|
|
if ! command -v certutil >/dev/null 2>&1; then
|
|
echo "entrypoint: warning — certutil not found (install libnss3-tools); Chrome/Chromium in this container will not trust the corporate CA"
|
|
return 0
|
|
fi
|
|
su -s /bin/bash claude -c '
|
|
db="$HOME/.pki/nssdb"
|
|
mkdir -p "$db" || exit 1
|
|
if [ ! -f "$db/cert9.db" ]; then
|
|
certutil -d "sql:$db" -N --empty-password >/dev/null 2>&1 || exit 1
|
|
fi
|
|
for f in /usr/local/share/ca-certificates/triple-c-*.crt; do
|
|
[ -f "$f" ] || continue
|
|
nick="triple-c:$(basename "$f" .crt)"
|
|
# Delete first so re-running replaces rather than duplicates.
|
|
certutil -d "sql:$db" -D -n "$nick" >/dev/null 2>&1
|
|
certutil -d "sql:$db" -A -t "C,," -n "$nick" -i "$f" >/dev/null 2>&1 \
|
|
|| echo "entrypoint: warning — certutil could not add $nick"
|
|
done
|
|
' && echo "entrypoint: seeded Chrome/Chromium NSS database with the corporate CA" \
|
|
|| echo "entrypoint: warning — NSS database seeding failed (continuing)"
|
|
}
|
|
|
|
install_corporate_ca() {
|
|
local files fp stamp f base name count installed
|
|
|
|
files=$(ca_source_files)
|
|
|
|
if [ -z "$files" ]; then
|
|
# Nothing configured — but /usr/local/share is in the writable layer and
|
|
# `docker commit` bakes it into the project's snapshot image, so a cert
|
|
# installed by a previous configuration would ride that snapshot into
|
|
# every future container. Turning the setting off has to actively undo.
|
|
if ls "$CA_STORE/$CA_PREFIX"*.crt >/dev/null 2>&1; then
|
|
echo "entrypoint: removing previously installed corporate CA certificates"
|
|
rm -f "$CA_STORE/$CA_PREFIX"*.crt
|
|
update-ca-certificates --fresh >/dev/null 2>&1 \
|
|
|| echo "entrypoint: warning — update-ca-certificates failed while removing certificates"
|
|
rm -f "$CA_STAMP"
|
|
fi
|
|
if [ -e "$CA_SRC" ]; then
|
|
echo "entrypoint: warning — $CA_SRC holds no certificate files"
|
|
fi
|
|
return 0
|
|
fi
|
|
|
|
# Idempotent and cheap: the certs are already installed on a plain restart
|
|
# (the writable layer survives stop/start), so hash the sources and skip the
|
|
# work when nothing has moved. The NSS database is checked separately
|
|
# because it lives in the home volume and can be wiped independently.
|
|
fp=$(printf '%s\n' "$files" | xargs -d '\n' -r sha256sum 2>/dev/null | sha256sum | cut -d' ' -f1)
|
|
stamp=$(cat "$CA_STAMP" 2>/dev/null)
|
|
if [ -n "$fp" ] && [ "$fp" = "$stamp" ] && [ -s "$CA_BUNDLE" ]; then
|
|
if [ -f "$CA_NSSDB/cert9.db" ]; then
|
|
echo "entrypoint: corporate CA certificates already installed"
|
|
return 0
|
|
fi
|
|
ca_seed_nssdb
|
|
return 0
|
|
fi
|
|
|
|
mkdir -p "$CA_STORE" "$(dirname "$CA_STAMP")"
|
|
rm -f "$CA_STORE/$CA_PREFIX"*.crt
|
|
installed=0
|
|
|
|
while IFS= read -r f; do
|
|
[ -n "$f" ] || continue
|
|
base=$(basename "$f")
|
|
name="$CA_PREFIX$(ca_normalise_name "$base")"
|
|
count=$(grep -c -- '-----BEGIN CERTIFICATE-----' "$f" 2>/dev/null || true)
|
|
[ -n "$count" ] || count=0
|
|
if [ "$count" -gt 1 ]; then
|
|
# A corporate trust chain is usually delivered as one PEM holding
|
|
# root + intermediates. update-ca-certificates handles exactly one
|
|
# certificate per file, so split it.
|
|
awk -v out="$CA_STORE/${name%.crt}" '
|
|
/-----BEGIN CERTIFICATE-----/ { n++; f = out "-" n ".crt" }
|
|
n > 0 { print > f }
|
|
' "$f" && installed=$((installed + count))
|
|
elif [ "$count" -eq 1 ]; then
|
|
cp -f "$f" "$CA_STORE/$name" && installed=$((installed + 1))
|
|
else
|
|
echo "entrypoint: warning — $f holds no PEM certificate (DER is not supported), skipping"
|
|
fi
|
|
done <<< "$files"
|
|
|
|
chmod 644 "$CA_STORE/$CA_PREFIX"*.crt 2>/dev/null
|
|
|
|
if [ "$installed" -eq 0 ]; then
|
|
echo "entrypoint: warning — no usable certificates found under $CA_SRC"
|
|
return 0
|
|
fi
|
|
|
|
if update-ca-certificates >/dev/null 2>&1; then
|
|
echo "entrypoint: installed $installed corporate CA certificate(s) into the system trust store"
|
|
printf '%s' "$fp" > "$CA_STAMP"
|
|
else
|
|
echo "entrypoint: warning — update-ca-certificates failed; corporate certificates may not be trusted"
|
|
fi
|
|
|
|
ca_seed_nssdb
|
|
}
|
|
|
|
install_corporate_ca
|
|
|
|
# ── SSH key setup ──────────────────────────────────────────────────────────
|
|
# Host SSH dir is mounted read-only at /tmp/.host-ssh and merged into
|
|
# /home/claude/.ssh (which lives on the home volume) so we can fix permissions.
|
|
#
|
|
# This used to `rm -rf ~/.ssh` and copy the host dir over it on every start,
|
|
# which silently deleted any key generated or saved inside the container and
|
|
# overwrote container edits to config/known_hosts. Now it is a merge:
|
|
# - Files the container created are never touched, even if the host later
|
|
# gains a file of the same name (the host copy is skipped with a warning).
|
|
# - A file previously copied from the host is refreshed when the host copy
|
|
# changes, and removed when the host drops it — but only while it is still
|
|
# byte-identical to what we copied. Once edited in the container it is the
|
|
# container's.
|
|
# - known_hosts is unioned, never replaced (ssh appends to it at runtime).
|
|
# `.triple-c-host-files` records "<sha256>\t<relative path>" for every file we
|
|
# copied, which is how the two kinds of file are told apart. Without it (first
|
|
# start after upgrading from the wipe-and-copy entrypoint) a differing file is
|
|
# backed up to `<name>.triple-c-backup` before the host copy replaces it.
|
|
#
|
|
# The function body between the markers is executed by a unit test in
|
|
# app/src-tauri/src/docker/image.rs; keep it self-contained.
|
|
# >>> sync_host_ssh
|
|
sync_host_ssh() {
|
|
local src="$1" dest="$2"
|
|
local manifest="$dest/.triple-c-host-files"
|
|
local legacy=0 new_manifest f rel target src_sum cur_sum recorded
|
|
|
|
_ssh_sum() {
|
|
if [ -L "$1" ]; then
|
|
printf 'link:%s' "$(readlink "$1")" | sha256sum | cut -d' ' -f1
|
|
else
|
|
sha256sum < "$1" | cut -d' ' -f1
|
|
fi
|
|
}
|
|
|
|
mkdir -p "$dest"
|
|
[ -f "$manifest" ] || legacy=1
|
|
new_manifest=$(mktemp)
|
|
|
|
while IFS= read -r -d '' f; do
|
|
rel="${f#"$src"/}"
|
|
[ "$rel" = "known_hosts" ] && continue
|
|
target="$dest/$rel"
|
|
src_sum=$(_ssh_sum "$f")
|
|
if [ -e "$target" ] || [ -L "$target" ]; then
|
|
cur_sum=$(_ssh_sum "$target")
|
|
if [ "$cur_sum" != "$src_sum" ]; then
|
|
recorded=""
|
|
[ "$legacy" = 0 ] && recorded=$(awk -F'\t' -v r="$rel" '$2 == r { print $1; exit }' "$manifest")
|
|
if [ "$legacy" = 1 ]; then
|
|
cp -a "$target" "$target.triple-c-backup"
|
|
echo "entrypoint: ~/.ssh/$rel differs from host copy; kept old version as $rel.triple-c-backup"
|
|
elif [ -z "$recorded" ] || [ "$recorded" != "$cur_sum" ]; then
|
|
echo "entrypoint: keeping container's ~/.ssh/$rel (host copy not applied)"
|
|
continue
|
|
fi
|
|
rm -f "$target"
|
|
mkdir -p "$(dirname "$target")"
|
|
cp -a "$f" "$target"
|
|
fi
|
|
else
|
|
mkdir -p "$(dirname "$target")"
|
|
cp -a "$f" "$target"
|
|
fi
|
|
printf '%s\t%s\n' "$src_sum" "$rel" >> "$new_manifest"
|
|
done < <(find "$src" \( -type f -o -type l \) -print0)
|
|
|
|
# Drop files the host no longer provides, unless edited in the container.
|
|
if [ "$legacy" = 0 ]; then
|
|
while IFS=$'\t' read -r recorded rel; do
|
|
[ -n "$rel" ] || continue
|
|
if [ ! -e "$src/$rel" ] && [ ! -L "$src/$rel" ] \
|
|
&& { [ -e "$dest/$rel" ] || [ -L "$dest/$rel" ]; } \
|
|
&& [ "$(_ssh_sum "$dest/$rel")" = "$recorded" ]; then
|
|
rm -f "$dest/$rel"
|
|
fi
|
|
done < "$manifest"
|
|
fi
|
|
|
|
if [ -f "$src/known_hosts" ]; then
|
|
cat "$src/known_hosts" >> "$dest/known_hosts"
|
|
sort -u -o "$dest/known_hosts" "$dest/known_hosts"
|
|
fi
|
|
|
|
mv "$new_manifest" "$manifest"
|
|
unset -f _ssh_sum
|
|
}
|
|
# <<< sync_host_ssh
|
|
|
|
# On AWS Hybrid ~/.ssh is a link into the EFS mount; the root steps below then
|
|
# work on the real directory behind it, and only after aws_hybrid_ssh_dir has
|
|
# confirmed the link is the one Triple-C made. Any other link: nothing is
|
|
# merged. Docker: always /home/claude/.ssh, as before.
|
|
ssh_home_dir=/home/claude/.ssh
|
|
if [ "$triplec_aws" = 1 ] && [ -L "$ssh_home_dir" ]; then
|
|
ssh_home_dir=$(aws_hybrid_ssh_dir /home/claude) || {
|
|
echo "entrypoint: warning — ~/.ssh is a symlink Triple-C did not make; host SSH files not merged"
|
|
ssh_home_dir=""
|
|
}
|
|
fi
|
|
if [ -n "$ssh_home_dir" ] && [ -d /tmp/.host-ssh ]; then
|
|
sync_host_ssh /tmp/.host-ssh "$ssh_home_dir"
|
|
chown -R claude:claude "$ssh_home_dir"
|
|
chmod 700 "$ssh_home_dir"
|
|
find "$ssh_home_dir" -type f -name "id_*" ! -name "*.pub" -exec chmod 600 {} \;
|
|
find "$ssh_home_dir" -type f -name "*.triple-c-backup" -exec chmod 600 {} \;
|
|
find "$ssh_home_dir" -type f -name "*.pub" -exec chmod 644 {} \;
|
|
if [ -f "$ssh_home_dir/known_hosts" ]; then
|
|
chmod 644 "$ssh_home_dir/known_hosts"
|
|
fi
|
|
if [ -f "$ssh_home_dir/config" ]; then
|
|
chmod 600 "$ssh_home_dir/config"
|
|
fi
|
|
fi
|
|
|
|
# Append common host keys (avoid duplicates)
|
|
su -s /bin/bash claude -c '
|
|
mkdir -p /home/claude/.ssh
|
|
ssh-keyscan -t ed25519,rsa github.com gitlab.com bitbucket.org >> /home/claude/.ssh/known_hosts 2>/dev/null || true
|
|
sort -u -o /home/claude/.ssh/known_hosts /home/claude/.ssh/known_hosts
|
|
'
|
|
|
|
# ── AWS config setup ──────────────────────────────────────────────────────────
|
|
# Host AWS dir is mounted read-only at /tmp/.host-aws.
|
|
# Copy to /home/claude/.aws so AWS CLI can write to sso/cache and cli/cache.
|
|
if [ -d /tmp/.host-aws ]; then
|
|
rm -rf /home/claude/.aws
|
|
cp -a /tmp/.host-aws /home/claude/.aws
|
|
chown -R claude:claude /home/claude/.aws
|
|
chmod 700 /home/claude/.aws
|
|
# Ensure writable cache directories exist
|
|
mkdir -p /home/claude/.aws/sso/cache /home/claude/.aws/cli/cache
|
|
chown -R claude:claude /home/claude/.aws/sso /home/claude/.aws/cli
|
|
|
|
# Inline sso_session properties into profile sections so AWS SDKs that don't
|
|
# support the sso_session indirection format can resolve sso_region, etc.
|
|
if [ -f /home/claude/.aws/config ]; then
|
|
python3 -c '
|
|
import configparser, sys
|
|
c = configparser.ConfigParser()
|
|
c.read(sys.argv[1])
|
|
for sec in c.sections():
|
|
if not sec.startswith("profile ") and sec != "default":
|
|
continue
|
|
session = c.get(sec, "sso_session", fallback=None)
|
|
if not session or c.has_option(sec, "sso_start_url"):
|
|
continue
|
|
ss = f"sso-session {session}"
|
|
if not c.has_section(ss):
|
|
continue
|
|
for key in ("sso_start_url", "sso_region", "sso_registration_scopes"):
|
|
val = c.get(ss, key, fallback=None)
|
|
if val:
|
|
c.set(sec, key, val)
|
|
with open(sys.argv[1], "w") as f:
|
|
c.write(f)
|
|
' /home/claude/.aws/config 2>/dev/null || true
|
|
fi
|
|
fi
|
|
|
|
# ── Git credential helper (for HTTPS token) ─────────────────────────────────
|
|
if [ -n "$GIT_TOKEN" ]; then
|
|
CRED_FILE="/home/claude/.git-credentials"
|
|
: > "$CRED_FILE"
|
|
chmod 600 "$CRED_FILE"
|
|
chown claude:claude "$CRED_FILE"
|
|
echo "https://oauth2:${GIT_TOKEN}@github.com" >> "$CRED_FILE"
|
|
echo "https://oauth2:${GIT_TOKEN}@gitlab.com" >> "$CRED_FILE"
|
|
echo "https://oauth2:${GIT_TOKEN}@bitbucket.org" >> "$CRED_FILE"
|
|
git config --file /home/claude/.gitconfig credential.helper "store --file=$CRED_FILE"
|
|
unset GIT_TOKEN
|
|
fi
|
|
|
|
# ── Git user config ──────────────────────────────────────────────────────────
|
|
if [ -n "$GIT_USER_NAME" ]; then
|
|
git config --file /home/claude/.gitconfig user.name "$GIT_USER_NAME"
|
|
fi
|
|
if [ -n "$GIT_USER_EMAIL" ]; then
|
|
git config --file /home/claude/.gitconfig user.email "$GIT_USER_EMAIL"
|
|
fi
|
|
chown claude:claude /home/claude/.gitconfig 2>/dev/null || true
|
|
|
|
# ── AWS: clone the project's repositories ───────────────────────────────────
|
|
# An AWS workspace has no project folder to mount; its repositories are cloned
|
|
# into /workspace/<folder> once the credential helper, git identity and ~/.ssh
|
|
# are in place — as `claude`, with prompts off and a per-repo time limit. A
|
|
# folder that is already a repository is left alone. Failures are reported and
|
|
# never stop the start: a workspace with one repo missing is still a workspace.
|
|
#
|
|
# In the background, started after the agent (start_clone_repos below): the
|
|
# app gives a starting task's agent only seconds to answer, so a clone in the
|
|
# way of the agent would fail every start with a large repository. Terminals
|
|
# work while the repos arrive. Progress, for the app to show later, is in
|
|
# /run/triple-c-clone (world-readable, root-written): `repos` gets a
|
|
# "<folder>\tcloning" line as a clone begins and a
|
|
# "<folder>\t<cloned|failed|exists>" line when it ends (the last line for a
|
|
# folder is its state), and `done` appears when all are finished. The idle
|
|
# watcher counts an unfinished clone as activity; triple-c-wip-push skips a
|
|
# folder still `cloning`.
|
|
# >>> aws_repos
|
|
# clone_repos json root [status_dir]
|
|
clone_repos() {
|
|
local json="$1" root="$2" status_dir="${3:-}" folder url branch dest existed err rc
|
|
local limit="${triplec_clone_timeout:-600}"
|
|
[ -n "$json" ] || return 0
|
|
_clone_status() { [ -z "$status_dir" ] || printf '%s\t%s\n' "$1" "$2" >> "$status_dir/repos"; }
|
|
while IFS= read -r -d '' folder && IFS= read -r -d '' url && IFS= read -r -d '' branch; do
|
|
dest="$root/$folder"
|
|
if [ -e "$dest/.git" ]; then
|
|
echo "entrypoint: /workspace/$folder is already a repository; not cloning"
|
|
_clone_status "$folder" exists
|
|
continue
|
|
fi
|
|
existed=0
|
|
[ -e "$dest" ] && existed=1
|
|
local args=(clone --quiet)
|
|
[ -n "$branch" ] && args+=(--branch "$branch")
|
|
args+=(-- "$url" "$dest")
|
|
echo "entrypoint: cloning $folder..."
|
|
_clone_status "$folder" cloning
|
|
# BatchMode is appended to whatever ssh command the user's git config
|
|
# names (core.sshCommand), read as the user, rather than replacing it.
|
|
err=$(_triplec_as_user sh -c '
|
|
limit=$1; shift
|
|
c=${GIT_SSH_COMMAND:-$(git config --get core.sshCommand)}
|
|
export GIT_SSH_COMMAND="${c:-ssh} -o BatchMode=yes" GIT_TERMINAL_PROMPT=0
|
|
exec timeout -k 10 "$limit" git "$@"' _ "$limit" "${args[@]}" 2>&1 </dev/null)
|
|
rc=$?
|
|
if [ "$rc" -eq 0 ]; then
|
|
echo "entrypoint: cloned $folder"
|
|
_clone_status "$folder" cloned
|
|
continue
|
|
fi
|
|
[ "$rc" -eq 124 ] || [ "$rc" -eq 137 ] && err="timed out after ${limit}s"
|
|
# Don't leave a half-made clone that the next start would skip.
|
|
[ "$existed" = 1 ] || rm -rf "$dest"
|
|
echo "Triple-C: clone of $folder failed: $(printf '%s' "$err" | tail -n 1)"
|
|
_clone_status "$folder" failed
|
|
done < <(printf '%s' "$json" | python3 -I -c '
|
|
import json, sys
|
|
def say(msg):
|
|
print("Triple-C: " + msg, file=sys.stderr)
|
|
try:
|
|
repos = json.load(sys.stdin)
|
|
except ValueError:
|
|
say("TRIPLEC_REPOS is not valid JSON; nothing cloned")
|
|
sys.exit(0)
|
|
if not isinstance(repos, list):
|
|
say("TRIPLEC_REPOS is not a JSON array; nothing cloned")
|
|
sys.exit(0)
|
|
def text(v):
|
|
if not isinstance(v, str) or "\0" in v or "\t" in v or "\n" in v:
|
|
return False
|
|
try:
|
|
v.encode("utf-8")
|
|
except UnicodeError:
|
|
return False
|
|
return True
|
|
for i, r in enumerate(repos):
|
|
if not isinstance(r, dict):
|
|
say("skipping repository %d: not an object" % i)
|
|
continue
|
|
url, branch, folder = r.get("url"), r.get("branch"), r.get("folder")
|
|
if not text(folder) or folder in ("", ".", "..") or "/" in folder:
|
|
say("skipping repository %d: bad folder %a" % (i, folder))
|
|
continue
|
|
if not text(url) or not url:
|
|
say("skipping %s: bad url" % folder)
|
|
continue
|
|
if branch is not None and not text(branch):
|
|
say("skipping %s: bad branch" % folder)
|
|
continue
|
|
sys.stdout.write("%s\0%s\0%s\0" % (folder, url, branch or ""))
|
|
')
|
|
unset -f _clone_status
|
|
return 0
|
|
}
|
|
|
|
# Runs clone_repos in the background, recording progress in $2.
|
|
start_clone_repos() {
|
|
local json="$1" status_dir="$2"
|
|
[ -n "$json" ] || return 0
|
|
rm -rf "$status_dir"
|
|
mkdir -m 755 "$status_dir" || status_dir=""
|
|
(
|
|
trap '' HUP
|
|
# `done` however the clone ends (an error, a signal), or the idle
|
|
# watcher would count it as still running forever.
|
|
[ -z "$status_dir" ] || trap ': > "$status_dir/done"' EXIT
|
|
clone_repos "$json" /workspace "$status_dir"
|
|
) &
|
|
}
|
|
# <<< aws_repos
|
|
|
|
# ── Claude instructions ──────────────────────────────────────────────────────
|
|
if [ -n "$CLAUDE_INSTRUCTIONS" ]; then
|
|
mkdir -p /home/claude/.claude
|
|
printf '%s\n' "$CLAUDE_INSTRUCTIONS" > /home/claude/.claude/CLAUDE.md
|
|
chown claude:claude /home/claude/.claude/CLAUDE.md
|
|
unset CLAUDE_INSTRUCTIONS
|
|
fi
|
|
|
|
# ── Mission Control setup ───────────────────────────────────────────────────
|
|
if [ "$MISSION_CONTROL_ENABLED" = "1" ]; then
|
|
MC_HOME="/home/claude/mission-control"
|
|
MC_LINK="/workspace/mission-control"
|
|
if [ ! -d "$MC_HOME" ]; then
|
|
echo "entrypoint: installing mission-control..."
|
|
cp -r /opt/mission-control "$MC_HOME"
|
|
chown -R claude:claude "$MC_HOME"
|
|
else
|
|
echo "entrypoint: mission-control already present, skipping install"
|
|
fi
|
|
# Symlink into workspace so Claude sees it at /workspace/mission-control
|
|
ln -sfn "$MC_HOME" "$MC_LINK"
|
|
chown -h claude:claude "$MC_LINK"
|
|
|
|
# Install skills to ~/.claude/skills/ so Claude Code discovers them automatically
|
|
if [ -d "$MC_HOME/.claude/skills" ]; then
|
|
mkdir -p /home/claude/.claude/skills
|
|
cp -r "$MC_HOME/.claude/skills/"* /home/claude/.claude/skills/ 2>/dev/null
|
|
chown -R claude:claude /home/claude/.claude/skills
|
|
echo "entrypoint: mission-control skills installed to ~/.claude/skills/"
|
|
fi
|
|
|
|
unset MISSION_CONTROL_ENABLED
|
|
fi
|
|
|
|
# ── Feature skills ──────────────────────────────────────────────────────────
|
|
# Skills owned by a Triple-C feature rather than by Mission Control. Installed
|
|
# when the feature is on, removed when it is off: ~/.claude is a persisted
|
|
# volume, so a skill left behind after its feature is disabled would keep
|
|
# telling an agent to use a capability the container no longer has.
|
|
#
|
|
# Copied on every start rather than only when absent, so a fix to a skill
|
|
# reaches projects that already have the old copy. Local edits under these
|
|
# directories do not survive — treat /opt/triple-c-skills as the source.
|
|
#
|
|
# The source lives in the *base image*, so a project whose container predates it
|
|
# recreates from its own snapshot and has no /opt/triple-c-skills to copy from.
|
|
# That case says so rather than returning silently: the toggle is on, the
|
|
# capability is there, and the skill simply never appears — which is impossible
|
|
# to work out from the outside.
|
|
install_feature_skill() {
|
|
local _name="$1"
|
|
local _enabled="$2"
|
|
local _src="/opt/triple-c-skills/$1"
|
|
local _dest="/home/claude/.claude/skills/$1"
|
|
|
|
# Reject anything that is not a plain directory name. The disabled branch
|
|
# `rm -rf`s $_dest under a *persisted volume*, so a blank name would take the
|
|
# whole skills directory (Mission Control's included) and `../x` would escape
|
|
# it entirely. Only the literal `pia-vpn` is passed today; this is so that
|
|
# stays true.
|
|
case "$_name" in
|
|
''|*/*|.*) echo "entrypoint: install_feature_skill: bad skill name '$_name'"; return 1 ;;
|
|
esac
|
|
|
|
if [ "$_enabled" = "1" ]; then
|
|
if [ ! -d "$_src" ]; then
|
|
echo "entrypoint: $_name skill unavailable — this container's base image predates it; migrate the project to get it"
|
|
return 0
|
|
fi
|
|
# Checked, not assumed: with no `set -e` in this script every step here
|
|
# can fail (full volume, read-only mount, a file where the directory
|
|
# should be) and the success line would still print.
|
|
mkdir -p /home/claude/.claude/skills || {
|
|
echo "entrypoint: $_name skill install FAILED (cannot create ~/.claude/skills)"; return 1; }
|
|
# Not just $_dest: when Mission Control is off nothing else creates the
|
|
# parent, so root would own it and `claude` could not add a skill there.
|
|
chown claude:claude /home/claude/.claude/skills
|
|
# Stage then swap. Copying over the live path meant a failure (full
|
|
# volume, read-only mount) left a truncated SKILL.md and no script
|
|
# behind, root-owned, on a persisted volume — which Claude Code then
|
|
# discovers and loads.
|
|
rm -rf "$_dest.new"
|
|
cp -r "$_src" "$_dest.new" || {
|
|
rm -rf "$_dest.new"
|
|
echo "entrypoint: $_name skill install FAILED (copy from $_src); previous copy left intact"
|
|
return 1; }
|
|
chown -R claude:claude "$_dest.new"
|
|
rm -rf "$_dest"
|
|
mv "$_dest.new" "$_dest"
|
|
echo "entrypoint: $_name skill installed to ~/.claude/skills/"
|
|
elif [ -e "$_dest" ] || [ -L "$_dest" ]; then
|
|
# -e/-L rather than -d: a leftover *file* at that path must go too.
|
|
rm -rf "$_dest"
|
|
echo "entrypoint: $_name skill removed (feature disabled)"
|
|
fi
|
|
}
|
|
|
|
install_feature_skill pia-vpn "${VPN_SUPPORT_ENABLED:-0}"
|
|
unset VPN_SUPPORT_ENABLED
|
|
|
|
# ── Claude Code settings ────────────────────────────────────────────────────
|
|
# Apply the managed Claude Code settings to ~/.claude/settings.json, keeping
|
|
# every key the user set inside the container.
|
|
#
|
|
# `settings.json` lives on the persisted triple-c-claude-config-{id} volume, so
|
|
# it outlives the container and a plain `.[0] * .[1]` merge could only ever
|
|
# *add*. That is what made every one of these settings one-way: switching one
|
|
# off in Triple-C omitted its key, the merge preserved the old on-value, and the
|
|
# setting stayed on until a destructive Reset. So Rust states the whole managed
|
|
# key set on every start, in two parts: CLAUDE_CODE_SETTINGS_JSON holds the keys
|
|
# that have a value, and CLAUDE_CODE_SETTINGS_CLEAR is a JSON array of the key
|
|
# names whose neutral state is *unset* (`tui`, `effortLevel`, `viewMode`,
|
|
# `awaySummaryEnabled`) and which must therefore be deleted rather than pinned
|
|
# to a stand-in value.
|
|
#
|
|
# The two are kept apart rather than using a null-means-delete payload because
|
|
# a project recreates from its own snapshot image, which carries whatever
|
|
# entrypoint it was built with. An older one merges with a plain `.[0] * .[1]`
|
|
# and would write literal nulls into the user's settings.json; it ignores
|
|
# CLAUDE_CODE_SETTINGS_CLEAR instead, keeping the old sticky behaviour until the
|
|
# project is migrated or Reset.
|
|
# See `build_claude_code_settings_json` in app/src-tauri/src/docker/container.rs.
|
|
if [ -n "$CLAUDE_CODE_SETTINGS_JSON" ]; then
|
|
SETTINGS_FILE="/home/claude/.claude/settings.json"
|
|
mkdir -p /home/claude/.claude
|
|
# One code path for "file exists" and "file doesn't".
|
|
[ -f "$SETTINGS_FILE" ] || printf '{}\n' > "$SETTINGS_FILE"
|
|
MERGED=$(jq -s --argjson clear "${CLAUDE_CODE_SETTINGS_CLEAR:-[]}" '
|
|
.[0] as $current
|
|
| .[1] as $set
|
|
| ($current * $set) | delpaths($clear | map([.]))
|
|
' "$SETTINGS_FILE" <(printf '%s' "$CLAUDE_CODE_SETTINGS_JSON") 2>/dev/null)
|
|
if [ -n "$MERGED" ]; then
|
|
printf '%s\n' "$MERGED" > "$SETTINGS_FILE"
|
|
else
|
|
echo "entrypoint: warning — failed to merge Claude Code settings into $SETTINGS_FILE"
|
|
fi
|
|
chown claude:claude "$SETTINGS_FILE"
|
|
chmod 600 "$SETTINGS_FILE"
|
|
unset CLAUDE_CODE_SETTINGS_JSON
|
|
unset CLAUDE_CODE_SETTINGS_CLEAR
|
|
fi
|
|
|
|
# ── AWS SSO auth refresh command ──────────────────────────────────────────────
|
|
# When set (Bedrock + profile/SSO auth), inject awsAuthRefresh into
|
|
# ~/.claude.json so Claude Code calls triple-c-sso-refresh when AWS credentials
|
|
# expire mid-session. When NOT set, strip any awsAuthRefresh left behind by a
|
|
# previous Bedrock-profile session — ~/.claude.json lives in the persisted home
|
|
# volume, so without this the container keeps trying to run the SSO refresh even
|
|
# after switching to a non-SSO backend (Anthropic/Ollama) or to static creds.
|
|
# Replace ~/.claude.json atomically: write a sibling temp file, then rename.
|
|
#
|
|
# `> "$CLAUDE_JSON"` truncates before it writes, so a write that fails part-way
|
|
# — a full home volume being the obvious way, and bounding that volume is what
|
|
# half this release is about — leaves the file unparseable. It holds the OAuth
|
|
# account, and the damage does not self-heal: the next start's `jq` fails on the
|
|
# corrupt file, `MERGED` comes back empty, and the `[ -n "$MERGED" ]` guard
|
|
# skips the write that would have repaired it. `triple-c-task-runner` has done
|
|
# it this way all along.
|
|
#
|
|
# On AWS Hybrid storage ~/.claude.json is a link into the EFS mount, and
|
|
# renaming over the link would swap it for a plain file and the state would
|
|
# quietly stop persisting. So the write goes to the link's target — but only
|
|
# when the link is exactly the one link_persistent_home makes and its target
|
|
# is not itself a link, and it is done *as claude*: that directory is
|
|
# claude-writable, so root must not write, rename or chown anything in it.
|
|
# Docker mode never takes that branch.
|
|
# >>> write_claude_json
|
|
write_claude_json() {
|
|
if [ "${triplec_aws:-0}" = 1 ] && [ -L "$CLAUDE_JSON" ]; then
|
|
_wcj_dest="$triplec_home_mnt/.claude.json"
|
|
if [ "$(readlink "$CLAUDE_JSON")" != "$_wcj_dest" ] || [ -L "$triplec_home_mnt" ] || [ -L "$_wcj_dest" ]; then
|
|
echo "entrypoint: warning — $CLAUDE_JSON is a symlink Triple-C did not make; not writing through it"
|
|
return 1
|
|
fi
|
|
if printf '%s\n' "$1" | _triplec_as_user sh -c \
|
|
'umask 077; cat > "$1.triple-c-tmp" && mv -f "$1.triple-c-tmp" "$1"' _ "$_wcj_dest"; then
|
|
return 0
|
|
fi
|
|
_triplec_as_user rm -f "$_wcj_dest.triple-c-tmp"
|
|
echo "entrypoint: warning — could not write $CLAUDE_JSON (leaving it as it was)"
|
|
return 1
|
|
fi
|
|
_wcj_tmp="${CLAUDE_JSON}.triple-c-tmp"
|
|
if printf '%s\n' "$1" > "$_wcj_tmp" 2>/dev/null; then
|
|
mv -f "$_wcj_tmp" "$CLAUDE_JSON" 2>/dev/null || rm -f "$_wcj_tmp"
|
|
else
|
|
rm -f "$_wcj_tmp"
|
|
echo "entrypoint: warning — could not write $CLAUDE_JSON (leaving it as it was)"
|
|
return 1
|
|
fi
|
|
# By name, after the rename, so these land on the new inode.
|
|
chown claude:claude "$CLAUDE_JSON"
|
|
chmod 600 "$CLAUDE_JSON"
|
|
}
|
|
# <<< write_claude_json
|
|
|
|
CLAUDE_JSON="/home/claude/.claude.json"
|
|
if [ -n "$AWS_SSO_AUTH_REFRESH_CMD" ]; then
|
|
if [ -f "$CLAUDE_JSON" ]; then
|
|
MERGED=$(jq --arg cmd "$AWS_SSO_AUTH_REFRESH_CMD" '.awsAuthRefresh = $cmd' "$CLAUDE_JSON" 2>/dev/null)
|
|
if [ -n "$MERGED" ]; then
|
|
write_claude_json "$MERGED"
|
|
fi
|
|
else
|
|
# No existing file, so there is nothing to destroy — but go through the
|
|
# same helper so the owner and mode are set in one place.
|
|
write_claude_json "$(printf '{"awsAuthRefresh":"%s"}' "$AWS_SSO_AUTH_REFRESH_CMD")"
|
|
fi
|
|
unset AWS_SSO_AUTH_REFRESH_CMD
|
|
elif [ -f "$CLAUDE_JSON" ] && grep -q '"awsAuthRefresh"' "$CLAUDE_JSON" 2>/dev/null; then
|
|
# Only rewrite when the key is actually present, to avoid a needless jq
|
|
# reformat of ~/.claude.json on every start of a non-SSO backend.
|
|
MERGED=$(jq 'del(.awsAuthRefresh)' "$CLAUDE_JSON" 2>/dev/null)
|
|
if [ -n "$MERGED" ]; then
|
|
write_claude_json "$MERGED"
|
|
fi
|
|
fi
|
|
|
|
# ── Shift+Enter key binding ───────────────────────────────────────────────────
|
|
# Triple-C's terminals send ESC+CR (`\e\r`) on Shift+Enter — the same bytes
|
|
# `/terminal-setup` installs for VS Code, Cursor, Alacritty and Zed — and Claude
|
|
# Code decodes those unconditionally. What it cannot see is that the binding is
|
|
# already in place, so it keeps printing its "run /terminal-setup" tip. This
|
|
# flag is what that tip is gated on: purely cosmetic, and it changes nothing
|
|
# about how the sequence is decoded.
|
|
#
|
|
# $CLAUDE_JSON is already set by the awsAuthRefresh block above.
|
|
if [ -f "$CLAUDE_JSON" ]; then
|
|
# Only rewrite when the value isn't already true, to avoid a needless jq
|
|
# reformat of ~/.claude.json on every single start.
|
|
if ! grep -q '"shiftEnterKeyBindingInstalled"[[:space:]]*:[[:space:]]*true' "$CLAUDE_JSON" 2>/dev/null; then
|
|
# Atomic, via `write_claude_json` — see its comment for why a plain
|
|
# `>` on this file can permanently destroy the OAuth login.
|
|
MERGED=$(jq '.shiftEnterKeyBindingInstalled = true' "$CLAUDE_JSON" 2>/dev/null)
|
|
if [ -n "$MERGED" ]; then
|
|
write_claude_json "$MERGED"
|
|
fi
|
|
fi
|
|
else
|
|
# Nothing to destroy, but the helper owns the owner/mode too.
|
|
write_claude_json '{"shiftEnterKeyBindingInstalled":true}'
|
|
fi
|
|
|
|
# ── Docker socket permissions ────────────────────────────────────────────────
|
|
if [ "$triplec_aws" != 1 ] && [ -S /var/run/docker.sock ]; then
|
|
DOCKER_GID=$(stat -c '%g' /var/run/docker.sock)
|
|
if ! getent group "$DOCKER_GID" > /dev/null 2>&1; then
|
|
groupadd -g "$DOCKER_GID" docker-host
|
|
fi
|
|
DOCKER_GROUP=$(getent group "$DOCKER_GID" | cut -d: -f1)
|
|
usermod -aG "$DOCKER_GROUP" claude
|
|
fi
|
|
|
|
# ── Timezone setup ───────────────────────────────────────────────────────────
|
|
if [ -n "${TZ:-}" ]; then
|
|
if [ -f "/usr/share/zoneinfo/$TZ" ]; then
|
|
ln -sf "/usr/share/zoneinfo/$TZ" /etc/localtime
|
|
echo "$TZ" > /etc/timezone
|
|
echo "entrypoint: timezone set to $TZ"
|
|
else
|
|
echo "entrypoint: warning — timezone '$TZ' not found in /usr/share/zoneinfo"
|
|
fi
|
|
fi
|
|
|
|
# ── Browser / URL relay ──────────────────────────────────────────────────────
|
|
# Tools that open a browser (gh, aws sso login, gcloud, python webbrowser, ...)
|
|
# consult $BROWSER first. Point it at the relay shim, which forwards the URL to
|
|
# the host's browser over the terminal. The image already sets this as an ENV —
|
|
# that is what `docker exec` terminal sessions inherit — but exporting it here
|
|
# means the entrypoint's own children see it too, and (below) that it is
|
|
# captured into the cron environment file for scheduled tasks. Under cron there
|
|
# is no terminal, so the shim degrades to printing the URL into the task log.
|
|
if [ -x /usr/local/bin/triple-c-open ]; then
|
|
export BROWSER=/usr/local/bin/triple-c-open
|
|
fi
|
|
|
|
# ── Playwright browser config ───────────────────────────────────────────────
|
|
# Seed ~/.playwright/cli.config.json on every start.
|
|
#
|
|
# Without it `playwright-cli` resolves to channel `chrome` — system Google
|
|
# Chrome — with the Chromium sandbox ON, and these containers do not permit
|
|
# unprivileged user namespaces, so the browser aborts with "Failed to move to
|
|
# new namespace ... Operation not permitted". On a base image that no longer
|
|
# ships Google Chrome the same default fails the other way, with "Chromium
|
|
# distribution 'chrome' is not found". One cause, two error messages, and
|
|
# neither of them looks like a configuration problem.
|
|
#
|
|
# Seeded here rather than baked into the image because ~/.playwright is inside
|
|
# the home volume: an image copy would reach new projects only, and every
|
|
# existing project would stay broken forever. Written on every start from a
|
|
# source outside the volume, the way CLAUDE_INSTRUCTIONS and the Mission
|
|
# Control skills already are.
|
|
#
|
|
# --seed-config-only is the cheap path: no npm install, no browser download, no
|
|
# apt, no verify launch, nothing over the network. It writes one small file if
|
|
# it is absent and returns. Measured at ~2 ms. The heavier repairs stay
|
|
# on-demand — run `triple-c-playwright-heal` with no arguments for those.
|
|
if [ -x /usr/local/bin/triple-c-playwright-heal ]; then
|
|
/usr/local/bin/triple-c-playwright-heal --seed-config-only --quiet || \
|
|
echo "entrypoint: warning — playwright config seeding failed (browser view may not launch)"
|
|
fi
|
|
|
|
# ── Scheduler setup ─────────────────────────────────────────────────────────
|
|
SCHEDULER_DIR="/home/claude/.claude/scheduler"
|
|
mkdir -p "$SCHEDULER_DIR/tasks" "$SCHEDULER_DIR/logs" "$SCHEDULER_DIR/notifications"
|
|
chown -R claude:claude "$SCHEDULER_DIR"
|
|
|
|
# Start cron daemon (runs as root, executes jobs per user crontab)
|
|
cron
|
|
|
|
# Save environment variables for cron jobs (cron runs with a minimal env)
|
|
#
|
|
# HOME is deliberately NOT captured here. This entrypoint runs as root, so the
|
|
# snapshot would record HOME=/root — and the task runner sources this file with
|
|
# `set -a`, which would overwrite the HOME cron gives the job. Claude Code then
|
|
# looks for its OAuth credential at /root/.claude/.credentials.json instead of
|
|
# /home/claude/.claude/.credentials.json and every scheduled task dies with
|
|
# "Not logged in · Please run /login". Cron still needs a HOME, so it is written
|
|
# explicitly below with the value the `claude` user actually has.
|
|
ENV_FILE="$SCHEDULER_DIR/.env"
|
|
: > "$ENV_FILE"
|
|
env | while IFS='=' read -r key value; do
|
|
case "$key" in
|
|
ANTHROPIC_*|AWS_*|CLAUDE_CODE_*|TRIPLE_C_PERMISSION_MODE|PATH|LANG|TZ|COLORTERM|BROWSER|NODE_EXTRA_CA_CERTS|REQUESTS_CA_BUNDLE|SSL_CERT_FILE)
|
|
# Escape single quotes in value and write as KEY='VALUE'
|
|
escaped_value=$(printf '%s' "$value" | sed "s/'/'\\\\''/g")
|
|
printf "%s='%s'\n" "$key" "$escaped_value" >> "$ENV_FILE"
|
|
;;
|
|
esac
|
|
done
|
|
printf "HOME='/home/claude'\n" >> "$ENV_FILE"
|
|
chown claude:claude "$ENV_FILE"
|
|
chmod 600 "$ENV_FILE"
|
|
|
|
# Restore crontab from persisted task JSON files (survives container recreation)
|
|
if ls "$SCHEDULER_DIR/tasks/"*.json >/dev/null 2>&1; then
|
|
CRON_TMP=$(mktemp)
|
|
echo "# Triple-C scheduled tasks — managed by triple-c-scheduler" > "$CRON_TMP"
|
|
echo "# Do not edit manually; changes will be overwritten." >> "$CRON_TMP"
|
|
echo "" >> "$CRON_TMP"
|
|
for task_file in "$SCHEDULER_DIR/tasks/"*.json; do
|
|
[ -f "$task_file" ] || continue
|
|
enabled=$(jq -r '.enabled' "$task_file")
|
|
[ "$enabled" = "true" ] || continue
|
|
schedule=$(jq -r '.schedule' "$task_file")
|
|
id=$(jq -r '.id' "$task_file")
|
|
echo "$schedule /usr/local/bin/triple-c-task-runner $id" >> "$CRON_TMP"
|
|
done
|
|
crontab -u claude "$CRON_TMP" 2>/dev/null || true
|
|
rm -f "$CRON_TMP"
|
|
echo "entrypoint: restored crontab from persisted tasks"
|
|
fi
|
|
|
|
# ── Claude Code self-update ──────────────────────────────────────────────────
|
|
# Update the Claude Code CLI to the latest version on container start, before
|
|
# any terminal session launches `claude`. Runs as the claude user (the CLI is
|
|
# installed under /home/claude/.claude/bin). Non-fatal and time-bounded so a
|
|
# slow or offline network never blocks container readiness.
|
|
# The lock is shared with the per-session update that every Claude terminal
|
|
# runs before `exec claude` (commands/terminal_commands.rs, UPDATE_PRELUDE).
|
|
# "Container ready" is printed *after* this finishes, so a user who starts a
|
|
# project and immediately opens a tab would otherwise have two updaters
|
|
# rewriting ~/.claude/bin at once, and the session's `|| echo` would hide the
|
|
# damage right before it ran the result.
|
|
echo "entrypoint: checking for Claude Code updates..."
|
|
timeout 120 su -s /bin/bash claude -c 'export PATH="/home/claude/.claude/bin:/home/claude/.local/bin:$PATH"; flock -w 90 -E 0 /tmp/.triple-c-claude-update.lock claude update' \
|
|
&& echo "entrypoint: Claude Code is up to date" \
|
|
|| echo "entrypoint: warning — Claude Code update skipped or failed (continuing)"
|
|
|
|
# ── Stay alive, as root ──────────────────────────────────────────────────────
|
|
# The container lives exactly as long as this script: docker-init is PID 1 and
|
|
# exits when its one child does. So what keeps it alive must be something the
|
|
# claude user cannot kill. This used to end in
|
|
# exec su -s /bin/bash claude -c "exec sleep infinity"
|
|
# which hung the container's whole lifetime on a `sleep` owned by claude — and
|
|
# Claude Code runs as claude and routinely runs `pkill sleep`, `pkill -f …`,
|
|
# `killall` or `kill -9 -1` while testing something. Any of those stopped the
|
|
# container: every terminal disconnected and the app still said Running.
|
|
# Dropping to claude there bought nothing (it dates from the initial commit,
|
|
# with no stated reason, and nothing reads that process's owner); its one
|
|
# reader is the app's marketplace readiness probe, which now also matches the
|
|
# marker below (app/src-tauri/src/marketplace/sync.rs, READY_PROBE).
|
|
#
|
|
# * Unprivileged kills get EPERM on both this script and its sleep. Even
|
|
# `sudo pkill sleep` only kills the child, which the loop replaces; it takes
|
|
# a root kill of this script itself.
|
|
# * `docker stop`: docker-init forwards SIGTERM here, and bash runs the trap
|
|
# as soon as `wait` returns, so the container stops at once rather than
|
|
# sitting out Docker's grace period and being SIGKILLed.
|
|
# * The sleep runs as `triple-c-keepalive infinity` (exec -a), a root-owned
|
|
# command line nothing else has, and it exists only once every step above
|
|
# has finished — that is the readiness marker. Keep the name in step with
|
|
# READY_PROBE.
|
|
# * Respawns are throttled to about one a second. If the sleep cannot start
|
|
# (fork failing under a pids limit or a fork bomb) or dies at once, an
|
|
# unthrottled loop would spin a core at 100% exactly when the container is
|
|
# already in trouble. The pause is `read -t` on a FIFO nobody writes —
|
|
# a builtin, so it still works when fork does not — with `sleep 1` as the
|
|
# fallback should the FIFO be unavailable.
|
|
# ── triple-c-agent ──────────────────────────────────────────────────────────
|
|
# The app's way into the container on hosts without a Docker API (AWS, over
|
|
# an SSM port-forward). Started only when a token was provided, and only now,
|
|
# after every setup step above, so "the agent answers /v1/health" also means
|
|
# "the container is set up" — the AWS host's readiness signal.
|
|
#
|
|
# Same survival rules as the keepalive below, for the same reason: it runs as
|
|
# root under a root supervisor loop, so a claude-user `pkill`/`kill -9 -1`
|
|
# gets EPERM, and a crash is restarted (throttled: a binary that exits at
|
|
# once must not spin a core).
|
|
# >>> start_agent
|
|
start_agent() {
|
|
[ -n "${TRIPLEC_AGENT_TOKEN_FILE:-}" ] || return 0
|
|
if [ ! -x /usr/local/bin/triple-c-agent ]; then
|
|
echo "triple-c-agent: token given but no agent binary in this image — not starting it" >&2
|
|
return 0
|
|
fi
|
|
(
|
|
# Keeps the supervisor alive through a stray HUP. The agent resets
|
|
# every signal disposition and the mask in each exec it spawns, so this
|
|
# does not leak into commands (an ignored SIGHUP otherwise survives
|
|
# exec and turns every exec into `nohup`).
|
|
trap '' HUP
|
|
cd "$agent_cwd" || cd /
|
|
while :; do
|
|
agent_started=$SECONDS
|
|
env -i "${agent_env[@]}" /usr/local/bin/triple-c-agent
|
|
echo "triple-c-agent exited ($?) — restarting" >&2
|
|
[ $((SECONDS - agent_started)) -ge 5 ] || sleep 5
|
|
done
|
|
) &
|
|
}
|
|
# <<< start_agent
|
|
start_agent
|
|
|
|
# ── AWS: WIP push on stop, idle auto-stop ───────────────────────────────────
|
|
# aws_before_stop runs from the TERM trap below, before the keepalive goes:
|
|
# with TRIPLEC_WIP_PUSH=1 it pushes every repo's unsaved work to a
|
|
# triple-c/wip/<stamp> branch (as `claude`, bounded at 90 s), unless the app's
|
|
# stop guard recorded `pushed` or `discard` in /run/triple-c/stop-reason
|
|
# (written as root through the agent just before StopTask), or the idle
|
|
# watcher recorded `idle` (it pushes *before* signalling and only signals once
|
|
# nothing unsaved is left, so an idle stop never loses work). ECS gives a task
|
|
# `stopTimeout` seconds between SIGTERM and SIGKILL — 30 by default, 120 at
|
|
# most on Fargate — so the task definition must raise it for the push to
|
|
# finish. Once only: a second TERM during the push changes nothing.
|
|
#
|
|
# The idle watcher (TRIPLEC_IDLE_STOP_MINUTES set) runs as root under a
|
|
# supervisor loop like the agent's, so a claude-user `pkill` cannot switch
|
|
# auto-stop off. When the workspace is idle it records the reason "idle" and
|
|
# sends TERM to *this* script ($$) — not PID 1, which under ECS's
|
|
# initProcessEnabled is docker-init — so an idle stop and an ECS stop take
|
|
# this same trap and push at most once. An idle stop exits with status 75
|
|
# (triplec_idle_exit; Rust `aws::tasks::IDLE_EXIT_CODE`), so ECS reports it as
|
|
# EssentialContainerExited with that exit code and the app can say "stopped
|
|
# after being idle" rather than "crashed". Its environment is built from
|
|
# scratch: it needs none of the container's but TRIPLEC_WIP_PUSH.
|
|
# >>> aws_stop
|
|
triplec_idle_exit=75
|
|
aws_before_stop() {
|
|
[ "${TRIPLEC_HOST:-}" = aws ] || return 0
|
|
[ -z "${triplec_stopping:-}" ] || return 0
|
|
triplec_stopping=1
|
|
local reason=sigterm recorded
|
|
recorded=$(cat /run/triple-c/stop-reason 2>/dev/null)
|
|
case "$recorded" in
|
|
idle)
|
|
# The watcher already pushed (or found nothing to push).
|
|
triplec_exit_status=$triplec_idle_exit
|
|
echo "entrypoint: stopping (idle) — work in progress already handled by the idle watcher"
|
|
return 0 ;;
|
|
# The app's stop guard already pushed, or the user chose to stop
|
|
# without pushing: honour that instead of pushing again.
|
|
pushed|discard)
|
|
echo "entrypoint: stopping — work in progress already handled by Triple-C ($recorded); not pushing"
|
|
return 0 ;;
|
|
esac
|
|
if [ "${TRIPLEC_WIP_PUSH:-0}" = 1 ]; then
|
|
echo "entrypoint: stopping ($reason) — pushing work in progress..."
|
|
_triplec_as_user timeout -k 5 90 /usr/local/bin/triple-c-wip-push --reason "$reason" \
|
|
|| echo "entrypoint: warning — WIP push incomplete (see above)"
|
|
fi
|
|
return 0
|
|
}
|
|
|
|
start_idle_watch() {
|
|
local minutes="$1" signal_pid="$2"
|
|
mkdir -p /run/triple-c && chmod 700 /run/triple-c
|
|
rm -f /run/triple-c/stop-reason
|
|
if [ -z "${TRIPLEC_AGENT_TOKEN_FILE:-}" ]; then
|
|
echo "triple-c-idle-watch: no agent token, so no activity to read — idle stop will never fire" >&2
|
|
fi
|
|
(
|
|
trap '' HUP
|
|
while :; do
|
|
watch_started=$SECONDS
|
|
env -i PATH="$PATH" \
|
|
TRIPLEC_IDLE_STOP_MINUTES="$minutes" \
|
|
TRIPLEC_IDLE_SIGNAL_PID="$signal_pid" \
|
|
TRIPLEC_AGENT_TOKEN_FILE="${TRIPLEC_AGENT_TOKEN_FILE:-/dev/shm/triple-c/agent-token}" \
|
|
TRIPLEC_WIP_PUSH="${TRIPLEC_WIP_PUSH:-0}" \
|
|
/usr/local/bin/triple-c-idle-watch
|
|
rc=$?
|
|
# 0: it signalled the stop. 2: misconfigured, and a restart would
|
|
# only say so again.
|
|
[ "$rc" -eq 0 ] || [ "$rc" -eq 2 ] && break
|
|
echo "triple-c-idle-watch exited ($rc) — restarting" >&2
|
|
[ $((SECONDS - watch_started)) -ge 5 ] || sleep 5
|
|
done
|
|
) &
|
|
}
|
|
# <<< aws_stop
|
|
# The stop trap goes in before any background work starts (the idle watcher
|
|
# can signal this script; a clone is work a stop must account for), so a TERM
|
|
# from here on always runs aws_before_stop. Defined after aws_stop, which
|
|
# holds the function it calls.
|
|
keepalive_pid=""
|
|
stop_keepalive() {
|
|
[ "$triplec_aws" = 1 ] && aws_before_stop
|
|
[ -n "$keepalive_pid" ] && kill "$keepalive_pid" 2>/dev/null
|
|
exit "${triplec_exit_status:-0}"
|
|
}
|
|
trap stop_keepalive TERM INT HUP
|
|
if [ "$triplec_aws" = 1 ] && [ -n "${TRIPLEC_IDLE_STOP_MINUTES:-}" ]; then
|
|
start_idle_watch "$TRIPLEC_IDLE_STOP_MINUTES" "$$"
|
|
fi
|
|
# Repos are cloned in the background from here on — see clone_repos.
|
|
if [ "$triplec_aws" = 1 ]; then
|
|
start_clone_repos "$triplec_repos_json" /run/triple-c-clone
|
|
fi
|
|
|
|
echo "Triple-C container ready."
|
|
throttle_fifo=/run/triple-c-keepalive.throttle
|
|
rm -f "$throttle_fifo"
|
|
mkfifo -m 600 "$throttle_fifo" 2>/dev/null && exec 3<>"$throttle_fifo"
|
|
rm -f "$throttle_fifo"
|
|
respawn_pause() {
|
|
read -r -t 1 -u 3 _ 2>/dev/null
|
|
# >128 is read's timeout, i.e. it paused; anything else means no FIFO.
|
|
[ $? -gt 128 ] || sleep 1
|
|
}
|
|
while :; do
|
|
started=$SECONDS
|
|
(exec -a triple-c-keepalive sleep infinity 3>&-) &
|
|
keepalive_pid=$!
|
|
wait "$keepalive_pid"
|
|
[ $((SECONDS - started)) -ge 2 ] || respawn_pause
|
|
done
|