multigravity

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

shopt -s nullglob

BASE="${MULTIGRAVITY_HOME:-$HOME/AntigravityProfiles}"
cmd="${1-}"

abort() {
  echo "Error: $1" >&2
  exit 1
}

print_info() {
  echo "$1"
}

platform() {
  local raw
  raw="${MULTIGRAVITY_PLATFORM-}"
  if [ -z "$raw" ]; then
    raw="$(uname -s)"
  fi

  raw="$(printf '%s' "$raw" | tr '[:upper:]' '[:lower:]')"

  case "$raw" in
    darwin | macos | mac | osx)
      printf '%s\n' "darwin"
      ;;
    linux)
      printf '%s\n' "linux"
      ;;
    *)
      abort "unsupported platform '$raw'. Multigravity supports macOS and Linux."
      ;;
  esac
}

profile_dir() {
  printf '%s/%s\n' "$BASE" "$1"
}

user_data_dir() {
  local profile_path=$1

  case "$(platform)" in
    darwin)
      printf '%s/Library/Application Support/Antigravity\n' "$profile_path"
      ;;
    linux)
      printf '%s/.config/Antigravity\n' "$profile_path"
      ;;
  esac
}

extensions_dir() {
  local profile_path=$1
  printf '%s/.antigravity/extensions\n' "$profile_path"
}

default_user_data_dir() {
  case "$(platform)" in
    darwin)
      printf '%s/Library/Application Support/Antigravity\n' "$HOME"
      ;;
    linux)
      printf '%s/.config/Antigravity\n' "$HOME"
      ;;
  esac
}

default_extensions_dir() {
  printf '%s/.antigravity/extensions\n' "$HOME"
}

templates_dir() {
  printf '%s/.templates\n' "$BASE"
}

is_auth_only() {
  [ -f "$(profile_dir "$1")/.auth-only" ]
}

linux_launcher_dir() {
  printf '%s/.local/share/multigravity/launchers\n' "$HOME"
}

linux_launcher_path() {
  printf '%s/%s.sh\n' "$(linux_launcher_dir)" "$1"
}

linux_desktop_path() {
  printf '%s/.local/share/applications/multigravity-%s.desktop\n' "$HOME" "$1"
}

mac_shortcut_path() {
  printf '%s/Applications/Multigravity %s.app\n' "$HOME" "$1"
}

validate_name() {
  local name=$1

  if [[ -z "$name" ]]; then
    abort "profile name required"
  fi

  if ! [[ "$name" =~ ^[a-zA-Z0-9][a-zA-Z0-9-]*$ ]]; then
    abort "profile name must start with alphanumeric and contain only letters, numbers, or hyphens"
  fi
}

command_or_path() {
  local candidate=$1

  if [ -z "$candidate" ]; then
    return 1
  fi

  if [ -d "$candidate" ] || [ -x "$candidate" ]; then
    printf '%s\n' "$candidate"
    return 0
  fi

  if command -v "$candidate" >/dev/null 2>&1; then
    command -v "$candidate"
    return 0
  fi

  return 1
}

find_app() {
  local override candidate

  override="${MULTIGRAVITY_APP-}"
  if [ -n "$override" ] && command_or_path "$override" >/dev/null 2>&1; then
    command_or_path "$override"
    return 0
  fi

  case "$(platform)" in
    darwin)
      for candidate in \
        "/Applications/Antigravity.app" \
        "$HOME/Applications/Antigravity.app"
      do
        if [ -d "$candidate" ]; then
          printf '%s\n' "$candidate"
          return 0
        fi
      done
      ;;
    linux)
      for candidate in \
        "antigravity" \
        "/usr/share/antigravity/antigravity" \
        "/usr/bin/antigravity" \
        "/usr/local/bin/antigravity" \
        "$HOME/.local/bin/antigravity" \
        "$HOME/Applications/Antigravity.AppImage"
      do
        if command_or_path "$candidate" >/dev/null 2>&1; then
          command_or_path "$candidate"
          return 0
        fi
      done
      ;;
  esac

  return 1
}

require_app() {
  local app

  if ! app="$(find_app)"; then
    case "$(platform)" in
      darwin)
        abort "Antigravity.app was not found. Install Antigravity or set MULTIGRAVITY_APP to the app bundle path."
        ;;
      linux)
        abort "Antigravity was not found. Install the Linux app so 'antigravity' is on PATH, or set MULTIGRAVITY_APP to the executable path."
        ;;
    esac
  fi

  printf '%s\n' "$app"
}

create_profile_layout() {
  local profile_path=$1

  mkdir -p "$profile_path"
  mkdir -p "$(extensions_dir "$profile_path")"

  case "$(platform)" in
    darwin)
      mkdir -p "$profile_path/Library/Application Support"

      if [ ! -e "$profile_path/Library/Keychains" ] && [ -d "$HOME/Library/Keychains" ]; then
        ln -s "$HOME/Library/Keychains" "$profile_path/Library/Keychains"
      fi
      ;;
    linux)
      mkdir -p \
        "$profile_path/.config/Antigravity" \
        "$profile_path/.cache" \
        "$profile_path/.local/share" \
        "$profile_path/.local/state"
      ;;
  esac
}

create_auth_only_layout() {
  local profile_path=$1
  local default_data default_ext

  default_data="$(default_user_data_dir)"
  default_ext="$(default_extensions_dir)"

  mkdir -p "$profile_path"

  # Mark as auth-only
  touch "$profile_path/.auth-only"

  # Create user data dir (holds isolated auth/account state)
  local data_dir
  data_dir="$(user_data_dir "$profile_path")"
  mkdir -p "$data_dir/User"

  # Symlink shared settings from default installation
  if [ -d "$default_data/User" ]; then
    for item in settings.json keybindings.json snippets; do
      local src="$default_data/User/$item"
      local dest="$data_dir/User/$item"
      if [ -e "$src" ] && [ ! -e "$dest" ]; then
        ln -s "$src" "$dest"
      fi
    done
  fi

  # Symlink extensions to default (shared, not copied)
  local ext_dir
  ext_dir="$(extensions_dir "$profile_path")"
  if [ -d "$default_ext" ]; then
    # Remove the empty dir created by mkdir, replace with symlink
    rmdir "$ext_dir" 2>/dev/null || true
    ln -s "$default_ext" "$ext_dir"
  else
    mkdir -p "$ext_dir"
  fi

  case "$(platform)" in
    darwin)
      mkdir -p "$profile_path/Library/Application Support"
      if [ ! -e "$profile_path/Library/Keychains" ] && [ -d "$HOME/Library/Keychains" ]; then
        ln -s "$HOME/Library/Keychains" "$profile_path/Library/Keychains"
      fi
      ;;
    linux)
      mkdir -p \
        "$profile_path/.cache" \
        "$profile_path/.local/share" \
        "$profile_path/.local/state"
      ;;
  esac
}

script_path() {
  local installed dir

  installed="$(command -v multigravity 2>/dev/null || true)"
  if [ -n "$installed" ]; then
    printf '%s\n' "$installed"
    return 0
  fi

  dir="$(cd "$(dirname "$0")" && pwd)"
  printf '%s/%s\n' "$dir" "$(basename "$0")"
}

shell_quote() {
  printf '%q' "$1"
}

desktop_quote() {
  local value=$1

  value=${value//\\/\\\\}
  value=${value//\"/\\\"}
  value=${value//\$/\\$}
  value=${value//\`/\\\`}
  printf '"%s"' "$value"
}

create_shortcut_darwin() {
  local profile=$1
  local app_name="Multigravity $profile"
  local app_dir
  local run_script
  local launcher
  local icon_src

  app_dir="$(mac_shortcut_path "$profile")"
  run_script="$app_dir/Contents/MacOS/run"
  launcher="$(script_path)"
  icon_src="$(dirname "$launcher")/icon.icns"

  mkdir -p "$app_dir/Contents/MacOS"
  mkdir -p "$app_dir/Contents/Resources"

  cat <<EOF > "$run_script"
#!/usr/bin/env bash
export MULTIGRAVITY_HOME=$(shell_quote "$BASE")
exec $(shell_quote "$launcher") $(shell_quote "$profile") "\$@"
EOF

  chmod +x "$run_script"

  if [ -f "$icon_src" ]; then
    cp "$icon_src" "$app_dir/Contents/Resources/icon.icns"
  fi

  cat <<EOF > "$app_dir/Contents/Info.plist"
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
"http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
  <key>CFBundleExecutable</key>
  <string>run</string>
  <key>CFBundleIconFile</key>
  <string>icon</string>
  <key>CFBundleIdentifier</key>
  <string>com.multigravity.profile.$profile</string>
  <key>CFBundleName</key>
  <string>$app_name</string>
  <key>CFBundlePackageType</key>
  <string>APPL</string>
</dict>
</plist>
EOF

  print_info "Shortcut created: $app_dir"
}

create_shortcut_linux() {
  local profile=$1
  local launcher_root
  local launcher_path
  local desktop_path
  local launcher

  launcher_root="$(linux_launcher_dir)"
  launcher_path="$(linux_launcher_path "$profile")"
  desktop_path="$(linux_desktop_path "$profile")"
  launcher="$(script_path)"

  mkdir -p "$launcher_root"
  mkdir -p "$(dirname "$desktop_path")"

  cat <<EOF > "$launcher_path"
#!/usr/bin/env sh
export MULTIGRAVITY_HOME=$(shell_quote "$BASE")
exec $(shell_quote "$launcher") $(shell_quote "$profile") "\$@"
EOF

  chmod +x "$launcher_path"

  cat <<EOF > "$desktop_path"
[Desktop Entry]
Version=1.0
Type=Application
Name=Multigravity $profile
Comment=Launch the $profile Antigravity profile
Exec=$(desktop_quote "$launcher_path") %F
Icon=antigravity
Terminal=false
StartupNotify=false
StartupWMClass=Antigravity
Categories=TextEditor;Development;IDE;
MimeType=application/x-antigravity-workspace;
EOF

  print_info "Shortcut created: $desktop_path"
}

create_shortcut() {
  case "$(platform)" in
    darwin)
      create_shortcut_darwin "$1"
      ;;
    linux)
      create_shortcut_linux "$1"
      ;;
  esac
}

remove_shortcut() {
  local profile=$1
  local target

  case "$(platform)" in
    darwin)
      target="$(mac_shortcut_path "$profile")"
      if [ -d "$target" ]; then
        rm -rf "$target"
        print_info "Removed shortcut: $target"
      fi
      ;;
    linux)
      target="$(linux_launcher_path "$profile")"
      if [ -f "$target" ]; then
        rm -f "$target"
        print_info "Removed shortcut: $target"
      fi

      target="$(linux_desktop_path "$profile")"
      if [ -f "$target" ]; then
        rm -f "$target"
        print_info "Removed shortcut: $target"
      fi
      ;;
  esac
}

launch_profile() {
  local profile=$1
  shift || true

  local profile_path
  local app
  local data_dir
  local ext_dir

  profile_path="$(profile_dir "$profile")"
  if [ ! -d "$profile_path" ]; then
    abort "profile '$profile' does not exist. Run: multigravity new $profile"
  fi

  create_profile_layout "$profile_path"

  app="$(require_app)"
  data_dir="$(user_data_dir "$profile_path")"
  ext_dir="$(extensions_dir "$profile_path")"

  print_info "Launching Antigravity profile '$profile'"

  case "$(platform)" in
    darwin)
      HOME="$profile_path" open -n "$app" --args \
        --user-data-dir "$data_dir" \
        --extensions-dir "$ext_dir" \
        "$@"
      ;;
    linux)
      HOME="$profile_path" \
      XDG_CONFIG_HOME="$profile_path/.config" \
      XDG_CACHE_HOME="$profile_path/.cache" \
      XDG_DATA_HOME="$profile_path/.local/share" \
      XDG_STATE_HOME="$profile_path/.local/state" \
      "$app" \
        --user-data-dir "$data_dir" \
        --extensions-dir "$ext_dir" \
        "$@"
      ;;
  esac
}

list_profiles() {
  local entries=""
  local dir
  local raw=${1-}

  if [ "$raw" != "--raw" ]; then
    echo "Existing profiles:"
  fi

  if [ ! -d "$BASE" ]; then
    if [ "$raw" != "--raw" ]; then
      echo "(none)"
    fi
    return 0
  fi

  for dir in "$BASE"/*; do
    [ -d "$dir" ] || continue
    local name
    name="$(basename "$dir")"
    [ "$name" = ".templates" ] && continue
    entries="${entries}${name}"$'\n'
  done

  if [ -z "$entries" ]; then
    if [ "$raw" != "--raw" ]; then
      echo "(none)"
    fi
  else
    printf '%s' "$entries" | sort
  fi
}

new_profile() {
  local profile=""
  local auth_only=false
  local from_template=""

  while [ $# -gt 0 ]; do
    case "$1" in
      --auth-only) auth_only=true ;;
      --from) from_template="${2-}"; shift ;;
      -*) abort "unknown option: $1" ;;
      *) profile="$1" ;;
    esac
    shift
  done

  validate_name "$profile"

  local profile_path
  profile_path="$(profile_dir "$profile")"
  if [ -d "$profile_path" ]; then
    abort "profile '$profile' already exists"
  fi

  mkdir -p "$BASE"

  if [ -n "$from_template" ]; then
    local tpl_path
    tpl_path="$(templates_dir)/$from_template"
    if [ ! -d "$tpl_path" ]; then
      abort "template '$from_template' does not exist. Run: multigravity template list"
    fi
    print_info "Creating profile '$profile' from template '$from_template'..."
    cp -R "$tpl_path" "$profile_path"
  elif [ "$auth_only" = true ]; then
    create_auth_only_layout "$profile_path"
  else
    create_profile_layout "$profile_path"
  fi

  print_info "Created profile '$profile'"
  create_shortcut "$profile"
}

delete_profile() {
  local profile=$1
  local profile_path
  local confirm

  validate_name "$profile"

  profile_path="$(profile_dir "$profile")"
  if [ ! -d "$profile_path" ]; then
    abort "profile '$profile' does not exist"
  fi

  read -r -p "Delete profile '$profile' and all its data? [y/N] " confirm
  if [[ "$confirm" =~ ^[Yy]$ ]]; then
    rm -rf "$profile_path"
    remove_shortcut "$profile"
    print_info "Deleted profile '$profile'"
  else
    print_info "Aborted."
  fi
}

rename_profile() {
  local old=$1
  local new=$2
  local old_path
  local new_path

  validate_name "$old"
  validate_name "$new"

  old_path="$(profile_dir "$old")"
  new_path="$(profile_dir "$new")"

  if [ ! -d "$old_path" ]; then
    abort "profile '$old' does not exist"
  fi
  if [ -d "$new_path" ]; then
    abort "profile '$new' already exists"
  fi

  mv "$old_path" "$new_path"
  remove_shortcut "$old"
  create_shortcut "$new"

  print_info "Renamed profile '$old' to '$new'"
}

clone_profile() {
  local src=$1
  local dest=$2
  local src_path
  local dest_path

  validate_name "$src"
  validate_name "$dest"

  src_path="$(profile_dir "$src")"
  dest_path="$(profile_dir "$dest")"

  if [ ! -d "$src_path" ]; then
    abort "source profile '$src' does not exist"
  fi
  if [ -d "$dest_path" ]; then
    abort "destination profile '$dest' already exists"
  fi

  print_info "Cloning profile '$src' to '$dest'..."
  cp -R "$src_path" "$dest_path"
  create_shortcut "$dest"

  print_info "Successfully cloned '$src' to '$dest'"
}

doctor_cli() {
  local errors=0
  local warnings=0

  print_info "Checking multigravity environment..."

  # 1. Platform Check
  if platform &>/dev/null; then
    echo "  [✓] Platform: $(platform)"
  else
    echo "  [✗] Platform: Unknown"
    errors=$((errors + 1))
  fi

  # 2. Antigravity Installation
  if app=$(find_app); then
    echo "  [✓] Antigravity: Found at $app"
  else
    echo "  [✗] Antigravity: Not found. Ensure it is installed or set MULTIGRAVITY_APP."
    errors=$((errors + 1))
  fi

  # 3. Path Check
  local installed
  installed="$(command -v multigravity 2>/dev/null || true)"
  if [ -n "$installed" ]; then
    echo "  [✓] Global Binary: $installed"
  else
    echo "  [!] Global Binary: Not found in PATH. Run install script or update PATH."
    warnings=$((warnings + 1))
  fi

  # 4. Icon Check (macOS)
  if [ "$(platform)" = "darwin" ]; then
    local icon_path
    icon_path="$(dirname "$(script_path)")/icon.icns"
    if [ -f "$icon_path" ]; then
      echo "  [✓] Application Icon: Found"
    else
      echo "  [!] Application Icon: Missing ($icon_path). Shortcuts will have default icons."
      warnings=$((warnings + 1))
    fi
  fi

  # 5. Base Directory
  if [ -d "$BASE" ]; then
    if [ -w "$BASE" ]; then
      echo "  [✓] Profile storage: $BASE (writable)"
    else
      echo "  [✗] Profile storage: $BASE (NOT writable)"
      errors=$((errors + 1))
    fi
  else
    echo "  [!] Profile storage: $BASE (Not yet created)"
  fi

  echo ""
  if [ $errors -eq 0 ]; then
    if [ $warnings -eq 0 ]; then
      print_info "✓ Your environment looks perfect!"
    else
      print_info "Found $warnings warning(s). Multigravity should still work, but some features might be degraded."
    fi
  else
    print_info "✗ Found $errors error(s) and $warnings warning(s). Please fix the errors above."
  fi
}

profile_stats() {
  if [ ! -d "$BASE" ]; then
    print_info "No profiles found."
    return 0
  fi

  print_info "Profile Storage Usage:"
  printf "%-20s %-10s %-10s\n" "PROFILE" "SIZE" "EXTENSIONS"
  printf "%-20s %-10s %-10s\n" "-------" "----" "----------"

  local dir
  for dir in "$BASE"/*; do
    [ -d "$dir" ] || continue
    local name
    name=$(basename "$dir")
    [ "$name" = ".templates" ] && continue

    local size
    if [ "$(uname -s)" = "Darwin" ]; then
      size=$(du -sh "$dir" | cut -f1)
    else
      size=$(du -sh "$dir" | cut -f1)
    fi

    local ext_count
    ext_count=$(ls -1 "$(extensions_dir "$dir")" 2>/dev/null | wc -l | xargs)
    [ -z "$ext_count" ] && ext_count=0

    printf "%-20s %-10s %-10s\n" "$name" "$size" "$ext_count"
  done

  echo ""
  local total
  total=$(du -sh "$BASE" | cut -f1)
  print_info "Total usage: $total"
}

update_cli() {
  local script_url="https://raw.githubusercontent.com/sujitagarwal/multigravity-cli/main/multigravity"
  local target
  target="$(script_path)"

  if [ -z "$target" ]; then
    abort "could not determine script path for update"
  fi

  print_info "Updating multigravity from $script_url ..."
  if curl -fsSL "$script_url" -o "$target.tmp"; then
    mv "$target.tmp" "$target"
    chmod +x "$target"
    print_info "Successfully updated multigravity!"
  else
    rm -f "$target.tmp"
    abort "failed to download update"
  fi
}

help_completion() {
  local shell_name
  shell_name="$(basename "$SHELL")"

  echo "To enable autocompletion, add the following to your shell profile:"
  echo ""
  case "$shell_name" in
    zsh)
      echo "  # Add to ~/.zshrc"
      echo '  source <(multigravity completion zsh)'
      ;;
    bash)
      echo "  # Add to ~/.bashrc"
      echo '  source <(multigravity completion bash)'
      ;;
    *)
      echo "  # Your shell ($shell_name) is not natively supported for completion."
      ;;
  esac
  echo ""
  echo "Then restart your terminal or run: source ~/.$shell_name""rc"
}

generate_completion() {
  local shell_type=$1
  case "$shell_type" in
    zsh)
      cat <<'EOF'
#compdef multigravity
_multigravity() {
    local -a commands
    commands=(
        'new:Create a new profile'
        'list:List existing profiles'
        'status:Show profile status (running, type, last used)'
        'rename:Rename a profile'
        'delete:Delete a profile'
        'clone:Clone an existing profile'
        'template:Manage profile templates (save, list, delete)'
        'export:Export a profile to tar.gz'
        'import:Import a profile from tar.gz'
        'update:Update multigravity'
        'doctor:Run system diagnosis'
        'stats:Show profile storage usage'
        'completion:Setup shell completion'
        'help:Show help'
    )
    local curcontext="$curcontext" state line
    _arguments -C '1: :->command' '*: :->args'
    case $state in
        command)
            _describe -t commands 'multigravity command' commands
            local -a profiles
            profiles=($(multigravity list --raw 2>/dev/null))
            (( ${#profiles} > 0 )) && _describe -t profiles 'profile' profiles
            ;;
        args)
            case $line[1] in
                rename|delete|clone|help)
                    local -a profiles
                    profiles=($(multigravity list --raw 2>/dev/null))
                    (( ${#profiles} > 0 )) && _describe -t profiles 'profile' profiles
                    ;;
            esac
            ;;
    esac
}
_multigravity "$@"
EOF
      ;;
    bash)
      cat <<'EOF'
_multigravity_completions() {
    local cur prev opts
    COMPREPLY=()
    cur="${COMP_WORDS[COMP_CWORD]}"
    prev="${COMP_WORDS[COMP_CWORD-1]}"
    opts="new list status rename delete clone template export import update doctor stats completion help"
 pocket

    if [[ ${COMP_CWORD} -eq 1 ]] ; then
        local profiles=$(multigravity list --raw 2>/dev/null)
        COMPREPLY=( $(compgen -W "${opts} ${profiles}" -- ${cur}) )
        return 0
    fi

    case "${prev}" in
        delete|rename|clone)
            local profiles=$(multigravity list --raw 2>/dev/null)
            COMPREPLY=( $(compgen -W "${profiles}" -- ${cur}) )
            return 0
            ;;
    esac
}
complete -F _multigravity_completions multigravity
EOF
      ;;
  esac
}

# ─── Template commands ────────────────────────────────────────────────────────

template_save() {
  local profile=$1
  local tpl_name=$2

  validate_name "$profile"
  validate_name "$tpl_name"

  local profile_path
  profile_path="$(profile_dir "$profile")"
  if [ ! -d "$profile_path" ]; then
    abort "profile '$profile' does not exist"
  fi

  local tpl_dir
  tpl_dir="$(templates_dir)"
  local tpl_path="$tpl_dir/$tpl_name"

  if [ -d "$tpl_path" ]; then
    abort "template '$tpl_name' already exists"
  fi

  mkdir -p "$tpl_dir"
  print_info "Saving profile '$profile' as template '$tpl_name'..."
  cp -R "$profile_path" "$tpl_path"

  # Remove auth-only marker from template (let the user choose on creation)
  rm -f "$tpl_path/.auth-only"

  print_info "Template '$tpl_name' saved"
}

template_list() {
  local tpl_dir
  tpl_dir="$(templates_dir)"

  echo "Available templates:"

  if [ ! -d "$tpl_dir" ]; then
    echo "  (none)"
    return 0
  fi

  local found=false
  for dir in "$tpl_dir"/*; do
    [ -d "$dir" ] || continue
    found=true
    local name
    name=$(basename "$dir")
    local size
    size=$(du -sh "$dir" 2>/dev/null | cut -f1)
    echo "  $name  ($size)"
  done

  if [ "$found" = false ]; then
    echo "  (none)"
  fi
}

template_delete() {
  local tpl_name=$1
  validate_name "$tpl_name"

  local tpl_path
  tpl_path="$(templates_dir)/$tpl_name"

  if [ ! -d "$tpl_path" ]; then
    abort "template '$tpl_name' does not exist"
  fi

  rm -rf "$tpl_path"
  print_info "Deleted template '$tpl_name'"
}

# ─── Status command ───────────────────────────────────────────────────────────

status_profiles() {
  if [ ! -d "$BASE" ]; then
    print_info "No profiles found."
    return 0
  fi

  printf "%-16s %-10s %-12s %-20s %s\n" "PROFILE" "STATUS" "TYPE" "LAST USED" "SIZE"
  printf "%-16s %-10s %-12s %-20s %s\n" "-------" "------" "----" "---------" "----"

  for dir in "$BASE"/*; do
    [ -d "$dir" ] || continue
    local name
    name=$(basename "$dir")

    # Skip .templates directory
    [ "$name" = ".templates" ] && continue

    # Check if running
    local status="stopped"
    local data_dir
    data_dir="$(user_data_dir "$dir")"
    if ps -eo args 2>/dev/null | grep -v grep | grep -qF "$data_dir" 2>/dev/null; then
      status="running"
    fi

    # Type
    local ptype="full"
    if [ -f "$dir/.auth-only" ]; then
      ptype="auth-only"
    fi

    # Last used (directory modification time)
    local last_used="unknown"
    case "$(platform)" in
      darwin)
        last_used=$(stat -f "%Sm" -t "%Y-%m-%d %H:%M" "$dir" 2>/dev/null || echo "unknown")
        ;;
      linux)
        last_used=$(stat -c "%y" "$dir" 2>/dev/null | cut -d'.' -f1 || echo "unknown")
        ;;
    esac

    # Size
    local size
    size=$(du -sh "$dir" 2>/dev/null | cut -f1)

    # Color for running status
    if [ "$status" = "running" ]; then
      printf "%-16s \033[32m%-10s\033[0m %-12s %-20s %s\n" "$name" "$status" "$ptype" "$last_used" "$size"
    else
      printf "%-16s %-10s %-12s %-20s %s\n" "$name" "$status" "$ptype" "$last_used" "$size"
    fi
  done
}

# ─── Export / Import ──────────────────────────────────────────────────────────

export_profile() {
  local profile=$1
  local output_path=${2-}

  validate_name "$profile"

  local profile_path
  profile_path="$(profile_dir "$profile")"
  if [ ! -d "$profile_path" ]; then
    abort "profile '$profile' does not exist"
  fi

  if [ -z "$output_path" ]; then
    output_path="./${profile}.tar.gz"
  fi

  print_info "Exporting profile '$profile'..."

  # Resolve symlinks before archiving (follow links)
  tar -czf "$output_path" -C "$BASE" "$profile"

  print_info "Exported to $output_path"
}

import_profile() {
  local archive_path=$1
  local profile=${2-}

  if [ -z "$archive_path" ]; then
    abort "usage: multigravity import <archive> [profile-name]"
  fi

  if [ ! -f "$archive_path" ]; then
    abort "file '$archive_path' not found"
  fi

  # Auto-detect profile name from archive if not provided
  if [ -z "$profile" ]; then
    profile=$(tar -tzf "$archive_path" 2>/dev/null | head -1 | cut -d'/' -f1)
    if [ -z "$profile" ]; then
      abort "could not determine profile name from archive. Specify a name: multigravity import <path> <name>"
    fi
  fi

  validate_name "$profile"

  local profile_path
  profile_path="$(profile_dir "$profile")"
  if [ -d "$profile_path" ]; then
    abort "profile '$profile' already exists"
  fi

  mkdir -p "$BASE"

  print_info "Importing profile as '$profile'..."

  # Check if archive root matches profile name
  local top_dir
  top_dir=$(tar -tzf "$archive_path" 2>/dev/null | head -1 | cut -d'/' -f1)

  if [ "$top_dir" = "$profile" ]; then
    tar -xzf "$archive_path" -C "$BASE"
  elif [ -n "$top_dir" ]; then
    tar -xzf "$archive_path" -C "$BASE"
    # Rename extracted dir if needed
    if [ "$top_dir" != "$profile" ] && [ -d "$BASE/$top_dir" ]; then
      mv "$BASE/$top_dir" "$profile_path"
    fi
  else
    mkdir -p "$profile_path"
    tar -xzf "$archive_path" -C "$profile_path"
  fi

  create_shortcut "$profile"
  print_info "Imported profile '$profile'"
}

usage() {
  cat <<EOF
Usage: multigravity <command> [args]

Commands:
  new <name> [options]    Create a new named profile + desktop shortcut
      --auth-only         Share extensions & settings, isolate only accounts
      --from <template>   Create from a saved template
  list                    List existing profiles
  status                  Show which profiles are running, type, last used
  rename <old> <new>      Rename a profile (updates its shortcut)
  delete <name>           Delete a profile and its data
  clone <src> <dest>      Clone an existing profile
  template save <profile> <name>   Save a profile as a reusable template
  template list           List available templates
  template delete <name>  Delete a template
  export <name> [path]    Export a profile to a tar.gz archive
  import <archive> [name] Import a profile from a tar.gz archive
  update                  Update multigravity to the latest version
  doctor                  Run a system diagnosis
  stats                   Show storage usage per profile
  completion              Show setup instructions for shell completion
  <name> [args...]        Launch Antigravity with the given profile
  help                    Show this help

Profile names: alphanumeric and hyphens only (e.g. work, personal, test-1)

Environment:
  MULTIGRAVITY_APP        Override the Antigravity app path or command
  MULTIGRAVITY_HOME       Override the profile storage directory
EOF
}

case "$cmd" in
  new)
    shift
    new_profile "$@"
    ;;
  list)
    list_profiles "${2-}"
    ;;
  rename)
    rename_profile "${2-}" "${3-}"
    ;;
  delete)
    delete_profile "${2-}"
    ;;
  clone)
    clone_profile "${2-}" "${3-}"
    ;;
  template)
    case "${2-}" in
      save)
        template_save "${3-}" "${4-}"
        ;;
      list)
        template_list
        ;;
      delete)
        template_delete "${3-}"
        ;;
      *)
        abort "usage: multigravity template <save|list|delete>"
        ;;
    esac
    ;;
  status)
    status_profiles
    ;;
  export)
    export_profile "${2-}" "${3-}"
    ;;
  import)
    import_profile "${2-}" "${3-}"
    ;;
  update)
    update_cli
    ;;
  doctor)
    doctor_cli
    ;;
  stats)
    profile_stats
    ;;
  completion)
    if [ -n "${2-}" ]; then
      generate_completion "$2"
    else
      help_completion
    fi
    ;;
  help | --help | -h)
    usage
    ;;
  "")
    usage
    exit 1
    ;;
  *)
    launch_profile "$cmd" "${@:2}"
    ;;
esac