codex-profile

#!/usr/bin/env bash
set -euo pipefail

MAIN_HOME="${CODEX_MAIN_HOME:-$HOME/.codex}"
PROFILE_BASE="${CODEX_PROFILE_BASE:-$HOME/.codex-profiles}"
SHARED_HOME="${CODEX_SHARED_HOME:-$HOME/.codex-shared}"

SHARED_DIRS=(
  "sessions"
  "memories"
  "rules"
  "skills"
  "shell_snapshots"
)

SHARED_FILES=(
  "AGENTS.md"
  "history.jsonl"
  "session_index.jsonl"
  "config.toml"
  "models_cache.json"
)

usage() {
  cat <<EOF
codex-profile - Multi-profile manager for OpenAI Codex CLI

Usage:
  codex-profile init
  codex-profile add <profile-name>
  codex-profile list
  codex-profile path <profile-name>
  codex-profile login <profile-name>
  codex-profile run <profile-name> [codex args...]
  codex-profile resume <profile-name> [codex resume args...]
  codex-profile status
  codex-profile help

Overview:
  codex-profile lets you use multiple Codex CLI profiles while sharing
  selected local context files between them.

  Each profile keeps its own authentication and runtime state:

    - auth.json
    - state_*.sqlite
    - logs_*.sqlite
    - cache/
    - log/
    - tmp/

  Shared context items are linked from the main Codex home:

    - sessions/
    - session_index.jsonl
    - history.jsonl
    - memories/
    - rules/
    - skills/
    - shell_snapshots/
    - AGENTS.md
    - config.toml
    - models_cache.json

  This allows another Codex profile to resume previous sessions and use the
  same rules, memories, skills, and MCP configuration, while keeping auth files
  isolated per profile.

Commands:
  init
      Initialize the shared context link directory.

      Default main Codex home:
        \$HOME/.codex

      Default shared link directory:
        \$HOME/.codex-shared

      This command does not move files from the main Codex home.
      It creates symlinks in the shared directory pointing back to the main home.

      Example:
        codex-profile init

  add <profile-name>
      Create a new Codex profile.

      Default profile path:
        \$HOME/.codex-profiles/<profile-name>

      The new profile gets symlinks to shared context items.
      Authentication and runtime state remain profile-specific.

      Examples:
        codex-profile add backup
        codex-profile add work
        codex-profile add api

  list
      List the main profile and additional profiles.

      Example:
        codex-profile list

  path <profile-name>
      Print the CODEX_HOME path for a profile.

      Example:
        codex-profile path backup

  login <profile-name>
      Run "codex login" with the selected profile's CODEX_HOME.

      If the profile does not exist, it is created first.

      Example:
        codex-profile login backup

      Equivalent:
        CODEX_HOME="\$HOME/.codex-profiles/backup" codex login

  run <profile-name> [codex args...]
      Run Codex with the selected profile.

      If the profile does not exist, it is created first.

      Examples:
        codex-profile run backup
        codex-profile run backup exec "review this repository"
        codex-profile run work --model gpt-5.1-codex

      Equivalent:
        CODEX_HOME="\$HOME/.codex-profiles/backup" codex [args...]

  resume <profile-name> [codex resume args...]
      Run "codex resume" with the selected profile.

      If the profile does not exist, it is created first.

      Examples:
        codex-profile resume backup --last
        codex-profile resume backup --all

      Notes:
        --last
            Resume the latest session for the current working directory.

        --all
            Include sessions from other working directories in the picker.

      Equivalent:
        CODEX_HOME="\$HOME/.codex-profiles/backup" codex resume [args...]

  status
      Show main home, shared home, profiles, and shared symlinks.

      Example:
        codex-profile status

Environment variables:
  CODEX_MAIN_HOME
      Main Codex home directory.

      Default:
        \$HOME/.codex

  CODEX_PROFILE_BASE
      Base directory for additional profiles.

      Default:
        \$HOME/.codex-profiles

  CODEX_SHARED_HOME
      Shared symlink directory.

      Default:
        \$HOME/.codex-shared

Recommended aliases:
  alias codex-main='CODEX_HOME="\$HOME/.codex" codex'
  alias codex-backup='codex-profile run backup'
  alias codex-backup-resume='codex-profile resume backup --last'
  alias codex-backup-resume-all='codex-profile resume backup --all'

Typical workflow:
  1. Initialize shared context:
       codex-profile init

  2. Create a new profile:
       codex-profile add backup

  3. Log in with the new profile:
       codex-profile login backup

  4. Run Codex with the profile:
       codex-profile run backup

  5. Resume the previous session with another profile:
       codex-profile resume backup --last

Safety model:
  Shared:
    - sessions
    - memories
    - rules
    - skills
    - config.toml
    - AGENTS.md
    - history.jsonl
    - session_index.jsonl

  Not shared:
    - auth.json
    - installation_id
    - state_*.sqlite
    - logs_*.sqlite
    - cache/
    - log/
    - tmp/
    - version.json

Important:
  This tool is designed for sequential profile switching.

  Do not run multiple Codex profiles at the same time while sharing the same
  sessions/history files. Concurrent writes may corrupt or desynchronize local
  Codex state.

  The script does not move files from the main Codex home. The shared directory
  contains symlinks pointing back to the main profile.

Example symlink structure:
  ~/.codex/config.toml
      ^
  ~/.codex-shared/config.toml -> ~/.codex/config.toml
      ^
  ~/.codex-profiles/backup/config.toml -> ~/.codex-shared/config.toml

Authentication remains isolated:
  ~/.codex/auth.json
  ~/.codex-profiles/backup/auth.json
EOF
}

die() {
  echo "ERROR: $*" >&2
  exit 1
}

validate_profile_name() {
  local profile_name="$1"

  [[ -n "$profile_name" ]] || die "Profile name is required."

  if [[ ! "$profile_name" =~ ^[a-zA-Z0-9._-]+$ ]]; then
    die "Invalid profile name: $profile_name"
  fi

  if [[ "$profile_name" == "." || "$profile_name" == ".." ]]; then
    die "Invalid profile name: $profile_name"
  fi

  case "$profile_name" in
    main|shared|default)
      die "Reserved profile name: $profile_name"
      ;;
  esac
}

ensure_base_dirs() {
  mkdir -p "$MAIN_HOME"
  mkdir -p "$PROFILE_BASE"
  mkdir -p "$SHARED_HOME"
}

path_exists_or_is_symlink() {
  local target_path="$1"
  [[ -e "$target_path" || -L "$target_path" ]]
}

safe_symlink() {
  local target_path="$1"
  local link_path="$2"
  local parent_dir

  parent_dir="$(dirname "$link_path")"
  mkdir -p "$parent_dir"

  if path_exists_or_is_symlink "$link_path" && [[ ! -L "$link_path" ]]; then
    echo "exists and is not a symlink, skipped: $link_path"
    return 1
  fi

  rm -f "$link_path"
  ln -s "$target_path" "$link_path"
}

link_dir_from_main_to_shared() {
  local shared_item="$1"
  local main_path="$MAIN_HOME/$shared_item"
  local shared_link="$SHARED_HOME/$shared_item"

  if ! path_exists_or_is_symlink "$main_path"; then
    mkdir -p "$main_path"
  fi

  if [[ ! -d "$main_path" && ! -L "$main_path" ]]; then
    echo "not a directory, skipped: $main_path"
    return
  fi

  safe_symlink "$main_path" "$shared_link" >/dev/null || return

  echo "shared dir: $shared_link -> $main_path"
}

link_file_from_main_to_shared() {
  local shared_item="$1"
  local main_path="$MAIN_HOME/$shared_item"
  local shared_link="$SHARED_HOME/$shared_item"

  if ! path_exists_or_is_symlink "$main_path"; then
    echo "missing main file, skipped: $shared_item"
    return
  fi

  if [[ ! -f "$main_path" && ! -L "$main_path" ]]; then
    echo "not a regular file, skipped: $main_path"
    return
  fi

  safe_symlink "$main_path" "$shared_link" >/dev/null || return

  echo "shared file: $shared_link -> $main_path"
}

link_shared_item_into_profile() {
  local profile_home="$1"
  local shared_item="$2"
  local shared_path="$SHARED_HOME/$shared_item"
  local profile_path="$profile_home/$shared_item"

  if ! path_exists_or_is_symlink "$shared_path"; then
    echo "missing shared item, skipped: $shared_path"
    return
  fi

  safe_symlink "$shared_path" "$profile_path" >/dev/null || return

  echo "profile link: $profile_path -> $shared_path"
}

init_shared() {
  local shared_item

  ensure_base_dirs

  for shared_item in "${SHARED_DIRS[@]}"; do
    link_dir_from_main_to_shared "$shared_item"
  done

  for shared_item in "${SHARED_FILES[@]}"; do
    link_file_from_main_to_shared "$shared_item"
  done

  echo
  echo "Initialized shared Codex context:"
  echo "  main:   $MAIN_HOME"
  echo "  shared: $SHARED_HOME"
}

link_shared_into_profile() {
  local profile_home="$1"
  local shared_item

  mkdir -p "$profile_home"

  for shared_item in "${SHARED_DIRS[@]}"; do
    link_shared_item_into_profile "$profile_home" "$shared_item"
  done

  for shared_item in "${SHARED_FILES[@]}"; do
    link_shared_item_into_profile "$profile_home" "$shared_item"
  done
}

add_profile() {
  local profile_name="$1"
  local profile_home

  validate_profile_name "$profile_name"

  profile_home="$PROFILE_BASE/$profile_name"

  init_shared >/dev/null

  mkdir -p "$profile_home"
  link_shared_into_profile "$profile_home"

  echo
  echo "Profile created:"
  echo "  name:       $profile_name"
  echo "  CODEX_HOME: $profile_home"
  echo
  echo "Login:"
  echo "  CODEX_HOME=\"$profile_home\" codex login"
  echo
  echo "Run:"
  echo "  CODEX_HOME=\"$profile_home\" codex"
  echo
  echo "Resume:"
  echo "  CODEX_HOME=\"$profile_home\" codex resume --last"
}

list_profiles() {
  ensure_base_dirs

  echo "main -> $MAIN_HOME"

  if [[ -d "$PROFILE_BASE" ]]; then
    find "$PROFILE_BASE" -mindepth 1 -maxdepth 1 -type d -printf "%f -> %p\n" | sort
  fi
}

profile_path() {
  local profile_name="$1"

  validate_profile_name "$profile_name"

  echo "$PROFILE_BASE/$profile_name"
}

login_profile() {
  local profile_name="$1"
  local profile_home

  validate_profile_name "$profile_name"

  profile_home="$PROFILE_BASE/$profile_name"

  if [[ ! -d "$profile_home" ]]; then
    add_profile "$profile_name" >/dev/null
  fi

  CODEX_HOME="$profile_home" codex login
}

run_profile() {
  local profile_name="$1"
  local profile_home

  shift
  validate_profile_name "$profile_name"

  profile_home="$PROFILE_BASE/$profile_name"

  if [[ ! -d "$profile_home" ]]; then
    add_profile "$profile_name" >/dev/null
  fi

  CODEX_HOME="$profile_home" codex "$@"
}

resume_profile() {
  local profile_name="$1"
  local profile_home

  shift
  validate_profile_name "$profile_name"

  profile_home="$PROFILE_BASE/$profile_name"

  if [[ ! -d "$profile_home" ]]; then
    add_profile "$profile_name" >/dev/null
  fi

  CODEX_HOME="$profile_home" codex resume "$@"
}

show_status() {
  ensure_base_dirs

  echo "Main:"
  echo "  $MAIN_HOME"
  echo
  echo "Shared:"
  echo "  $SHARED_HOME"
  echo
  echo "Profiles:"
  list_profiles
  echo
  echo "Shared links:"
  find "$SHARED_HOME" -maxdepth 1 -type l -printf "  %f -> %l\n" | sort || true
}

main() {
  local command="${1:-}"

  shift || true

  case "$command" in
    init)
      init_shared
      ;;
    add)
      [[ $# -eq 1 ]] || die "Usage: codex-profile add <profile-name>"
      add_profile "$1"
      ;;
    list)
      list_profiles
      ;;
    path)
      [[ $# -eq 1 ]] || die "Usage: codex-profile path <profile-name>"
      profile_path "$1"
      ;;
    login)
      [[ $# -eq 1 ]] || die "Usage: codex-profile login <profile-name>"
      login_profile "$1"
      ;;
    run)
      [[ $# -ge 1 ]] || die "Usage: codex-profile run <profile-name> [codex args...]"
      run_profile "$@"
      ;;
    resume)
      [[ $# -ge 1 ]] || die "Usage: codex-profile resume <profile-name> [codex resume args...]"
      resume_profile "$@"
      ;;
    status)
      show_status
      ;;
    -h|--help|help|"")
      usage
      ;;
    *)
      die "Unknown command: $command"
      ;;
  esac
}

main "$@"