set -euo pipefail

usage() {

}

resolve_bin_path() {

}

case "${1:-}" in

-h|--help) usage; exit 0 ;;

RUN_AFTER_BUILD=0

ARG_PROFILE=""

WORKSPACE_CHOICE="${WORKSPACE:-}"

PASSTHROUGH_ARGS=()

while [ $# -gt 0 ]; do

case "$1" in

run)

RUN_AFTER_BUILD=1

PASSTHROUGH_ARGS+=("$1")

;;

--workspace)

shift || { echo "Error: --workspace requires a value." >&2; usage; exit 1; }

WORKSPACE_CHOICE="$1"

;;

--workspace=*)

WORKSPACE_CHOICE="${1#*=}"

;;

-h|--help)

usage

exit 0

;;

*)

if [ -n "$ARG_PROFILE" ]; then

echo "Error: Multiple profile arguments provided ('${ARG_PROFILE}' and '$1')." >&2

usage

exit 1

fi

ARG_PROFILE="$1"

PASSTHROUGH_ARGS+=("$1")

;;

esac

shift

if [ -z "$WORKSPACE_CHOICE" ]; then

WORKSPACE_CHOICE="code"

if [ "$WORKSPACE_CHOICE" = "both" ]; then

if [ "$RUN_AFTER_BUILD" -eq 1 ]; then

echo "Error: --workspace both cannot be combined with 'run'." >&2

exit 1

fi

for ws in codex code; do

WORKSPACE="$ws" "$0" "${PASSTHROUGH_ARGS[@]}" --workspace "$ws"

done

exit 0

if [ "$ARG_PROFILE" = "pref" ]; then

ARG_PROFILE="perf"

SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)"

CALLER_CWD="$(pwd)"

case "$WORKSPACE_CHOICE" in

codex|codex-rs)

WORKSPACE_DIR="codex-rs"

CRATE_PREFIX="codex"

;;

code|code-rs)

WORKSPACE_DIR="code-rs"

CRATE_PREFIX="code"

;;

*)

echo "Error: Unknown workspace '${WORKSPACE_CHOICE}'. Use codex, code, or both." >&2

exit 1

;;

WORKSPACE_PATH="${SCRIPT_DIR}/${WORKSPACE_DIR}"

if [ ! -d "$WORKSPACE_PATH" ]; then

echo "Error: Workspace directory '${WORKSPACE_PATH}' not found." >&2

exit 1

cd "${WORKSPACE_PATH}"

CLI_PACKAGE="$(sed -n 's/^name\s*=\s*"\(.*\)"/\1/p' cli/Cargo.toml | head -n1)"

TUI_PACKAGE="$(sed -n 's/^name\s*=\s*"\(.*\)"/\1/p' tui/Cargo.toml | head -n1)"

EXEC_PACKAGE="$(sed -n 's/^name\s*=\s*"\(.*\)"/\1/p' exec/Cargo.toml | head -n1)"

CRATE_PREFIX="${CLI_PACKAGE%%-*}"

EXEC_BIN="$(awk 'BEGIN{inbin=0} /^\[\[bin\]\]/{inbin=1; next} inbin && /^name[[:space:]]*=/{gsub(/.*"/,"",$0); gsub(/"/,"",$0); print; exit}' exec/Cargo.toml)"

if [ -z "${EXEC_BIN}" ]; then

EXEC_BIN="${EXEC_PACKAGE}"

REPO_ROOT="${SCRIPT_DIR}"

KEEP_ENV="${KEEP_ENV:-1}"

PROFILE_ENV_SUPPLIED=0

if [ -n "${PROFILE+x}" ]; then

PROFILE_ENV_SUPPLIED=1

PROFILE_VALUE="$PROFILE"

PROFILE_VALUE="dev-fast"

if [ -n "$ARG_PROFILE" ]; then

PROFILE_VALUE="$ARG_PROFILE"

PROFILE_EXPLICIT=0

if [ "$PROFILE_ENV_SUPPLIED" -eq 1 ] || [ -n "$ARG_PROFILE" ]; then

PROFILE_EXPLICIT=1

PROFILE="$PROFILE_VALUE"

if [ "${DETERMINISTIC:-}" = "1" ]; then

echo "Deterministic build: enabled"

DET_FORCE_REL="${DETERMINISTIC_FORCE_RELEASE:-1}"

if [ "$PROFILE" = "dev-fast" ] && [ "$DET_FORCE_REL" = "1" ]; then

PROFILE="release-prod"

echo "Deterministic build: switching profile to ${PROFILE}"

elif [ "$PROFILE" = "dev-fast" ]; then

echo "Deterministic build: keeping profile ${PROFILE} (DETERMINISTIC_FORCE_RELEASE=0)"

fi

# Use SOURCE_DATE_EPOCH if available to stabilize timestamps

if command -v git >/dev/null 2>&1 && git -C "$REPO_ROOT" rev-parse --is-inside-work-tree >/dev/null 2>&1; then

export SOURCE_DATE_EPOCH="$(git -C "$REPO_ROOT" log -1 --pretty=%ct 2>/dev/null || true)"

fi

# Keep debuginfo intact so profiling tools can resolve symbols.

ORIGINAL_PROFILE="$PROFILE"

if [ "$PROFILE" != "dev" ] && [ "$PROFILE" != "release" ]; then

if ! grep -F "[profile.${PROFILE}]" Cargo.toml >/dev/null 2>&1; then

case "$PROFILE" in

dev-fast)

PROFILE="dev"

;;

perf|release-prod)

PROFILE="release"

;;

*)

PROFILE="dev"

;;

esac

if [ "$ORIGINAL_PROFILE" != "$PROFILE" ]; then

echo "Profile ${ORIGINAL_PROFILE} not defined in ${WORKSPACE_DIR}/Cargo.toml; falling back to ${PROFILE}."

fi

fi

USE_CARGO="cargo"

if command -v rustup >/dev/null 2>&1; then

# Determine desired toolchain

if [ -n "${RUSTUP_TOOLCHAIN:-}" ]; then

TOOLCHAIN="$RUSTUP_TOOLCHAIN"

else

# Try parse channel from rust-toolchain.toml in repo root

if [ -f "rust-toolchain.toml" ]; then

TOOLCHAIN=$(sed -n 's/^channel\s*=\s*"\(.*\)"/\1/p' rust-toolchain.toml | head -n1)

fi

# Fallback to active default if none found

TOOLCHAIN="${TOOLCHAIN:-$(rustup show active-toolchain 2>/dev/null | awk '{print $1}')}"

fi

if [ -n "$TOOLCHAIN" ]; then

# Ensure toolchain is installed; if not, attempt install quietly

if ! rustup which rustc --toolchain "$TOOLCHAIN" >/dev/null 2>&1; then

echo "rustup: installing toolchain $TOOLCHAIN ..."

rustup toolchain install "$TOOLCHAIN" >/dev/null 2>&1 || true

fi

USE_CARGO="rustup run $TOOLCHAIN cargo"

echo "Using rustup toolchain: $TOOLCHAIN"

rustup run "$TOOLCHAIN" rustc --version || true

else

echo "rustup found but no toolchain detected; using system cargo"

fi

echo "Error: rustup is required for consistent builds."

echo "Please install rustup: https://rustup.rs/"

exit 1

if [ "${KEEP_ENV}" != "1" ]; then

# Only define RUSTFLAGS via feature flags like DETERMINISTIC=1; otherwise clear.

if [ -z "${DETERMINISTIC:-}" ]; then

export RUSTFLAGS=""

fi

unset RUSTC_WRAPPER CARGO_BUILD_RUSTC_WRAPPER SCCACHE SCCACHE_BIN CARGO_TARGET_DIR MACOSX_DEPLOYMENT_TARGET

unset CARGO_PROFILE_RELEASE_LTO CARGO_PROFILE_DEV_FAST_LTO CARGO_PROFILE_RELEASE_CODEGEN_UNITS CARGO_PROFILE_DEV_FAST_CODEGEN_UNITS

# Ensure incremental uses profile default

unset CARGO_INCREMENTAL

CANONICAL_ENV_APPLIED=1

CANONICAL_ENV_APPLIED=0

if [ "${DEBUG_SYMBOLS:-}" = "1" ]; then

if [ "$PROFILE" = "perf" ]; then

echo "Debug symbols: profile 'perf' already preserves debuginfo"

elif [ "$PROFILE_EXPLICIT" -eq 0 ] && [ "$PROFILE" = "dev-fast" ]; then

echo "Debug symbols requested: switching profile to perf"

PROFILE="perf"

else

PROFILE_ENV_KEY="$(printf "%s" "$PROFILE" | tr '[:lower:]-' '[:upper:]_')"

DEBUG_VAR="CARGO_PROFILE_${PROFILE_ENV_KEY}_DEBUG"

STRIP_VAR="CARGO_PROFILE_${PROFILE_ENV_KEY}_STRIP"

SPLIT_VAR="CARGO_PROFILE_${PROFILE_ENV_KEY}_SPLIT_DEBUGINFO"

printf -v "$DEBUG_VAR" '%s' '2'

printf -v "$STRIP_VAR" '%s' 'none'

printf -v "$SPLIT_VAR" '%s' 'packed'

export "$DEBUG_VAR" "$STRIP_VAR" "$SPLIT_VAR"

echo "Debug symbols: forcing debuginfo for profile ${PROFILE}"

fi

if [ -n "${RUSTFLAGS:-}" ]; then

CLEAN_RUSTFLAGS="${RUSTFLAGS//-C debuginfo=0/}"

CLEAN_RUSTFLAGS="${CLEAN_RUSTFLAGS// / }"

CLEAN_RUSTFLAGS="${CLEAN_RUSTFLAGS## }"

CLEAN_RUSTFLAGS="${CLEAN_RUSTFLAGS%% }"

export RUSTFLAGS="${CLEAN_RUSTFLAGS}"

fi

export CARGO_PROFILE_RELEASE_STRIP="none"

export CARGO_PROFILE_RELEASE_PROD_STRIP="none"

echo "Building ${CRATE_PREFIX} binary (${PROFILE} mode)..."

if [ "${STRICT_CARGO_HOME:-}" = "1" ]; then

export CARGO_HOME="${CARGO_HOME_ENFORCED:-${REPO_ROOT}/.cargo-home}"

# Default: write inside workspace if not set to avoid HOME permission issues

if [ -z "${CARGO_HOME:-}" ]; then

export CARGO_HOME="${REPO_ROOT}/.cargo-home"

fi

if [ -z "${RUSTUP_HOME:-}" ]; then

export RUSTUP_HOME="${CARGO_HOME%/}/rustup"

if [ -z "${CARGO_TARGET_DIR:-}" ]; then

export CARGO_TARGET_DIR="${WORKSPACE_PATH}/target"

mkdir -p "${CARGO_HOME}" "${CARGO_TARGET_DIR}" 2>/dev/null || true

mkdir -p ./target

REPO_TARGET_ABS="$(cd ./target >/dev/null 2>&1 && pwd)"

resolve_bin_path

export CARGO_REGISTRIES_CRATES_IO_PROTOCOL="sparse"

REAL_CARGO_BIN="$(rustup which cargo 2>/dev/null || command -v cargo || echo cargo)"

REAL_RUSTC_BIN="$(rustup which rustc 2>/dev/null || command -v rustc || echo rustc)"

HOST_TRIPLE="$(rustup run "$TOOLCHAIN" rustc -vV 2>/dev/null | awk -F': ' '/^host: /{print $2}')"

TRIPLE="${HOST_TRIPLE:-}"

if [ -z "$TRIPLE" ]; then

# Fallback for Darwin when rustup is unavailable for some reason

if [ "$(uname -s)" = "Darwin" ]; then

TRIPLE="$(uname -m)-apple-darwin"

[ "$TRIPLE" = "arm64-apple-darwin" ] && TRIPLE="aarch64-apple-darwin"

else

TRIPLE="unknown-unknown-unknown"

fi

if ! CARGO_HOME="$CARGO_HOME" RUSTUP_HOME="$RUSTUP_HOME" ${USE_CARGO} metadata --locked --format-version 1 >/dev/null 2>&1; then

echo "⚠️ Warning: Cargo.lock appears out of date or inconsistent"

echo " This might mean:"

echo " • You've modified Cargo.toml dependencies"

echo " • You've changed workspace crate versions"

echo " • The lockfile is missing entries"

echo ""

echo " Run 'cargo update' to update all dependencies, or"

echo " Run 'cargo update -p <crate-name>' to update specific crates"

echo ""

echo " Continuing with unlocked build for development..."

echo ""

USE_LOCKED=""

# Lockfile is valid, use it for consistent builds

USE_LOCKED="--locked"

if [ "${TRACE_BUILD:-}" = "1" ]; then

echo "--- TRACE_BUILD environment ---"

echo "whoami: $(whoami)"

echo "pwd: $(pwd)"

echo "SHELL: ${SHELL:-}"

bash --version | head -n1 || true

if [ -n "${TOOLCHAIN:-}" ]; then

echo "TOOLCHAIN: ${TOOLCHAIN}"

rustup run "$TOOLCHAIN" rustc -vV || true

rustup run "$TOOLCHAIN" cargo -vV || true

fi

echo "CANONICAL_ENV_APPLIED: ${CANONICAL_ENV_APPLIED} (KEEP_ENV=${KEEP_ENV})"

echo "Filtered env (CARGO|RUST*|PROFILE|CODE_HOME|CODEX_HOME):"

env | egrep '^(CARGO|RUST|RUSTUP|PROFILE|CODE_HOME|CODEX_HOME)=' | sort || true

echo "--------------------------------"

FPRINT_FILE="./target/${PROFILE}/.env-fingerprint"

collect_fingerprint() {

}

NEW_FPRINT_TEXT="$(collect_fingerprint)"

NEW_FPRINT_HASH="$(printf "%s" "$NEW_FPRINT_TEXT" | shasum -a 256 2>/dev/null | awk '{print $1}')"

FPRINT_CHANGED="0"

if [ -f "$FPRINT_FILE" ]; then

OLD_FPRINT_HASH="$(sed -n 's/^HASH=//p' "$FPRINT_FILE" 2>/dev/null | head -n1)"

if [ "${OLD_FPRINT_HASH:-}" != "$NEW_FPRINT_HASH" ]; then

FPRINT_CHANGED="1"

echo "⚠️ Build cache fingerprint changed since last run for profile '${PROFILE}'."

echo " This can trigger incremental rebuilds the first time you build."

if [ "${TRACE_BUILD:-}" = "1" ]; then

echo "--- previous fingerprint (hash: ${OLD_FPRINT_HASH:-none}) ---"; sed -n '1,200p' "$FPRINT_FILE" 2>/dev/null | sed '1d'; echo "--------------------------------"

echo "--- current fingerprint (hash: ${NEW_FPRINT_HASH}) ---"; printf "%s\n" "$NEW_FPRINT_TEXT"; echo "--------------------------------"

else

echo " Run with TRACE_BUILD=1 to see detailed differences."

fi

fi

if [ -z "${EXEC_BIN}" ]; then

EXEC_BIN="${CRATE_PREFIX}-exec"

echo "Using exec bin: ${EXEC_BIN}"

${USE_CARGO} build ${USE_LOCKED} --profile "${PROFILE}" --bin "${CRATE_PREFIX}" --bin "${CRATE_PREFIX}-tui" --bin "${EXEC_BIN}"

if [ $? -eq 0 ]; then

resolve_bin_path

if [ "$PROFILE" = "perf" ]; then

PERF_SOURCE="${BIN_CARGO_PATH}"

PERF_TARGET="${BIN_PATH}"

if [ -e "${PERF_SOURCE}" ]; then

PERF_DIR="$(dirname "${PERF_TARGET}")"

mkdir -p "${PERF_DIR}"

if [ -e "${PERF_TARGET}" ] || [ -L "${PERF_TARGET}" ]; then

rm -f "${PERF_TARGET}"

fi

(

cd "${PERF_DIR}" >/dev/null 2>&1

ln -sf "$(basename "${PERF_SOURCE}")" "$(basename "${PERF_TARGET}")"

)

fi

fi

echo "✅ Build successful!"

echo "Binary location: ${BIN_DISPLAY_PATH}"

echo ""

# Keep old symlink locations working for compatibility

# Create symlink in target/release for npm wrapper expectations

release_link_target="../${BIN_SUBDIR}/${BIN_FILENAME}"

dev_fast_link_target="../${BIN_SUBDIR}/${BIN_FILENAME}"

SYMLINK_PREFIXES=("${CRATE_PREFIX}")

if [ "${CRATE_PREFIX}" = "code" ]; then

SYMLINK_PREFIXES+=("coder")

fi

create_cli_symlinks() {

}

CLI_TARGET_CODE="../../target/${BIN_SUBDIR}/${BIN_FILENAME}"

CLI_TARGET_CODEX="../../${WORKSPACE_DIR}/target/${BIN_SUBDIR}/${BIN_FILENAME}"

CLI_LINK_ABSOLUTE=""

if [ "${TARGET_DIR_ABS}" != "${REPO_TARGET_ABS}" ]; then

release_link_target="${BIN_PATH}"

dev_fast_link_target="${BIN_PATH}"

CLI_LINK_ABSOLUTE="${BIN_PATH}"

# Maintain repo-local path for downstream tooling when target dir is external

if [ -n "${BIN_LINK_PATH:-}" ]; then

mkdir -p "$(dirname "${BIN_LINK_PATH}")"

if [ -e "${BIN_LINK_PATH}" ]; then

rm -f "${BIN_LINK_PATH}"

fi

ln -sf "${BIN_PATH}" "${BIN_LINK_PATH}"

fi

fi

mkdir -p ./target/release

if [ -e "./target/release/${CRATE_PREFIX}" ]; then

rm -f "./target/release/${CRATE_PREFIX}"

fi

ln -sf "${release_link_target}" "./target/release/${CRATE_PREFIX}"

# Update the symlinks in CLI wrapper directories

if [ -d "../codex-cli/bin" ]; then

create_cli_symlinks "../codex-cli/bin" "${CLI_TARGET_CODEX}"

fi

if [ -d "./code-cli/bin" ]; then

create_cli_symlinks "./code-cli/bin" "${CLI_TARGET_CODE}"

fi

# Ensure repo-local developer alias stays mapped to latest build output

# so the user's `${CRATE_PREFIX}-dev` alias keeps working when pointing at target/dev-fast/${CRATE_PREFIX}

# Only create this symlink if we're not already building in dev-fast profile

if [ "$PROFILE" != "dev-fast" ]; then

mkdir -p ./target/dev-fast

if [ -e "./target/dev-fast/${CRATE_PREFIX}" ]; then

rm -f "./target/dev-fast/${CRATE_PREFIX}"

fi

ln -sf "${dev_fast_link_target}" "./target/dev-fast/${CRATE_PREFIX}"

fi

# Optional post-link step for deterministic builds: re-link executables

# with -no_uuid only on macOS. Apply per-bin via `cargo rustc` so

# dependencies/proc-macro dylibs are not affected.

if [ "${DETERMINISTIC_NO_UUID:-}" = "1" ] && [ "$(uname -s)" = "Darwin" ]; then

echo "Deterministic post-link: removing LC_UUID from executables"

${USE_CARGO} rustc ${USE_LOCKED} --profile "${PROFILE}" -p "${CLI_PACKAGE}" --bin "${CRATE_PREFIX}" -- -C link-arg=-Wl,-no_uuid || true

${USE_CARGO} rustc ${USE_LOCKED} --profile "${PROFILE}" -p "${TUI_PACKAGE}" --bin "${CRATE_PREFIX}-tui" -- -C link-arg=-Wl,-no_uuid || true

${USE_CARGO} rustc ${USE_LOCKED} --profile "${PROFILE}" -p "${EXEC_PACKAGE}" --bin "${EXEC_BIN}" -- -C link-arg=-Wl,-no_uuid || true

fi

# Compute absolute path and SHA256 for clarity (after any post-linking)

ABS_BIN_PATH="${BIN_PATH}"

if [[ "${ABS_BIN_PATH}" != /* ]]; then

ABS_BIN_PATH="$(cd "$(dirname "${ABS_BIN_PATH}")" >/dev/null 2>&1 && pwd)/$(basename "${ABS_BIN_PATH}")"

fi

BIN_SHA=""

if [ -e "${ABS_BIN_PATH}" ]; then

if command -v shasum >/dev/null 2>&1; then

BIN_SHA="$(shasum -a 256 "${ABS_BIN_PATH}" | awk '{print $1}')"

elif command -v sha256sum >/dev/null 2>&1; then

BIN_SHA="$(sha256sum "${ABS_BIN_PATH}" | awk '{print $1}')"

fi

fi

if [ -n "$BIN_SHA" ]; then

echo "Binary Hash: ${BIN_SHA} ($(du -sh "${ABS_BIN_PATH}" | awk '{print $1}'))"

elif [ -e "${ABS_BIN_PATH}" ]; then

echo "Binary Size: $(du -h "${ABS_BIN_PATH}" | cut -f1)"

else

echo "Binary artifact not found at ${ABS_BIN_PATH}"

fi

if [ "$RUN_AFTER_BUILD" -eq 1 ]; then

if [ ! -x "${ABS_BIN_PATH}" ]; then

echo "❌ Run failed: ${ABS_BIN_PATH} is missing or not executable"

exit 1

fi

echo "Running ${ABS_BIN_PATH} (cwd: ${CALLER_CWD})..."

(

cd "${CALLER_CWD}" && "${ABS_BIN_PATH}"

)

RUN_STATUS=$?

if [ $RUN_STATUS -ne 0 ]; then

echo "❌ Run failed with status ${RUN_STATUS}"

exit $RUN_STATUS

fi

fi

if [ "${TRACE_BUILD:-}" = "1" ] && [ -n "$BIN_SHA" ]; then

echo "--- TRACE_BUILD artifact ---"

echo "ABS_BIN_PATH: ${ABS_BIN_PATH}"

echo "SHA256: ${BIN_SHA}"

echo "--------------------------------"

fi

# Persist the current fingerprint to explain future behavior

mkdir -p "./target/${PROFILE}" 2>/dev/null || true

{

echo "HASH=${NEW_FPRINT_HASH}"

printf "%s\n" "$NEW_FPRINT_TEXT"

} >"$FPRINT_FILE"

if [ "$FPRINT_CHANGED" = "1" ]; then

echo "🧰 Cache normalized to current environment (fingerprint ${NEW_FPRINT_HASH})."

fi

# If lockfile was out of date, remind user

if [ -z "$USE_LOCKED" ]; then

echo ""

echo "⚠️ Remember: Built without --locked due to Cargo.lock issues"

echo " Consider running 'cargo update' and committing the changes"

fi

echo "❌ Build failed"

exit 1