# Install build tools
wget https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage
chmod +x linuxdeploy-x86_64.AppImage

# Optional: plugin for Qt apps
wget https://github.com/linuxdeploy/linuxdeploy-plugin-qt/releases/download/continuous/linuxdeploy-plugin-qt-x86_64.AppImage
chmod +x linuxdeploy-plugin-qt-x86_64.AppImage

# For Python apps
wget https://github.com/niess/linuxdeploy-plugin-python/releases/download/continuous/linuxdeploy-plugin-python-x86_64.AppImage
chmod +x linuxdeploy-plugin-python-x86_64.AppImage

# appimagetool (if you want manual control)
wget https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage
chmod +x appimagetool-x86_64.AppImage

# 1. Create the AppDir
mkdir -p MyApp.AppDir/usr/{bin,lib,share/myapp}

# 2. Copy your binary
cp build/myapp MyApp.AppDir/usr/bin/

# 3. Create the .desktop file (required)
cat > MyApp.AppDir/myapp.desktop << 'EOF'
[Desktop Entry]
Name=MyApp
Exec=myapp
Icon=myapp
Type=Application
Categories=Utility;
Comment=My awesome application
EOF

# 4. Add an icon (required — 256x256 PNG minimum)
cp assets/myapp.png MyApp.AppDir/myapp.png
cp assets/myapp.png MyApp.AppDir/usr/share/myapp/

# 5. Create AppRun (the entry point)
cat > MyApp.AppDir/AppRun << 'APPRUN'
#!/bin/bash
set -e
SELF=$(readlink -f "$0")
HERE=${SELF%/*}
export PATH="${HERE}/usr/bin/:${PATH}"
export LD_LIBRARY_PATH="${HERE}/usr/lib/:${LD_LIBRARY_PATH}"
export XDG_DATA_DIRS="${HERE}/usr/share/:${XDG_DATA_DIRS}"
exec "${HERE}/usr/bin/myapp" "$@"
APPRUN
chmod +x MyApp.AppDir/AppRun

# 6. Bundle shared libraries (manual approach)
# Find what your binary needs:
ldd MyApp.AppDir/usr/bin/myapp

# Copy each .so that isn't a basic system library:
# Skip: libm, libc, libpthread, libdl, ld-linux (these are always present)
# Copy: everything else
cp /usr/lib/x86_64-linux-gnu/libssl.so.1.1 MyApp.AppDir/usr/lib/
cp /usr/lib/x86_64-linux-gnu/libcrypto.so.1.1 MyApp.AppDir/usr/lib/
# ... etc

# 7. Build the AppImage
./appimagetool-x86_64.AppImage MyApp.AppDir MyApp-1.0-x86_64.AppImage

# For a compiled app (C/C++, Rust, Go binary):
./linuxdeploy-x86_64.AppImage \
  --appdir MyApp.AppDir \
  --executable build/myapp \
  --desktop-file myapp.desktop \
  --icon-file assets/myapp.png \
  --output appimage

# For a Qt app:
export QMAKE=/usr/lib/qt5/bin/qmake  # Point to your Qt installation
./linuxdeploy-x86_64.AppImage \
  --appdir MyApp.AppDir \
  --executable build/myapp \
  --desktop-file myapp.desktop \
  --icon-file assets/myapp.png \
  --plugin qt \
  --output appimage

# For a Python app:
./linuxdeploy-x86_64.AppImage \
  --appdir MyApp.AppDir \
  --executable /usr/bin/python3 \
  --desktop-file myapp.desktop \
  --icon-file assets/myapp.png \
  --plugin python \
  --output appimage

# Check which glibc symbols your binary needs:
objdump -T build/myapp | grep GLIBC | sort -t@ -k2 | tail

# Output example:
# 0000...  GLIBC_2.33  memmove
# 0000...  GLIBC_2.34  pthread_create

# Build inside Ubuntu 20.04 container:
docker run --rm -v $(pwd):/build ubuntu:20.04 bash -c "
  apt-get update -qq
  apt-get install -y build-essential cmake ...
  cd /build
  cmake -B builddir && cmake --build builddir
"
# Now run linuxdeploy on the output

# For GitHub releases:
UPDATE_INFO="gh-releases-zsync|YourOrg|YourRepo|latest|MyApp-*-x86_64.AppImage.zsync"

./linuxdeploy-x86_64.AppImage \
  --appdir MyApp.AppDir \
  --executable build/myapp \
  --desktop-file myapp.desktop \
  --icon-file assets/myapp.png \
  --updateinformation "$UPDATE_INFO" \
  --output appimage

# Sign the AppImage with your GPG key:
./appimagetool-x86_64.AppImage \
  --sign \
  --sign-key YOUR_GPG_FINGERPRINT \
  MyApp.AppDir \
  MyApp-1.0-x86_64.AppImage

# This embeds the signature in an ELF section and creates MyApp-1.0-x86_64.AppImage.digest

# What's inside?
./MyApp.AppImage --appimage-extract
ls squashfs-root/

# Mount it for inspection (no extraction):
./MyApp.AppImage --appimage-mount
# Prints the mountpoint path, Ctrl+C to unmount

# Run the extracted binary directly (bypass FUSE):
squashfs-root/AppRun

# Extract and debug with strace:
./MyApp.AppImage --appimage-extract
strace -e openat squashfs-root/AppRun 2>&1 | grep "No such file"
# Shows every file it's trying to open that doesn't exist

# Check offset (useful for debugging self-extraction):
./MyApp.AppImage --appimage-offset

# Run without FUSE (useful when FUSE isn't available):
APPIMAGE_EXTRACT_AND_RUN=1 ./MyApp.AppImage

# Install snapcraft
sudo snap install snapcraft --classic

# Initialize LXD (snapcraft uses it for clean builds)
sudo snap install lxd
sudo lxd init --minimal
sudo usermod -aG lxd $USER
newgrp lxd

# Build the snap (downloads base, builds in LXD VM):
snapcraft

# Output: myapp_1.0.0_amd64.snap

# Install locally for testing:
sudo snap install myapp_1.0.0_amd64.snap --dangerous

# Test it:
snap run myapp

# Check what's blocked (AppArmor denials):
snap logs myapp

# Rebuild just a specific part (faster during development):
snapcraft clean myapp
snapcraft build myapp

# Debug shell inside the build environment:
snapcraft prime --debug  # drops you to a shell before packaging

# 1. Start with devmode (no confinement):
# In snapcraft.yaml: confinement: devmode

# 2. Install and test:
sudo snap install myapp_1.0.0_amd64.snap --dangerous --devmode

# 3. Watch AppArmor denials:
sudo journalctl -f | grep DENIED

# 4. Map denials to interfaces
# If you see: /run/user/1000/wayland-0 denied → need 'wayland' plug
# If you see: /home/user/.config/ denied → need 'home' plug
# If you see: network denied → need 'network' plug

# 5. Add plugs to snapcraft.yaml, rebuild:
snapcraft

# 6. Install in strict mode:
sudo snap install myapp_1.0.0_amd64.snap --dangerous
snap run myapp

# 7. Repeat until it works, then set confinement: strict

# Register your app name (one-time):
snapcraft register myapp

# Login to the store:
snapcraft login

# Upload:
snapcraft upload myapp_1.0.0_amd64.snap --release stable

# Or release a specific revision to a channel:
snapcraft release myapp 1 stable      # revision 1 → stable
snapcraft release myapp 1 candidate   # same revision to candidate

# Check status:
snapcraft status myapp

# Install flatpak and flatpak-builder
sudo apt install flatpak flatpak-builder    # Debian/Ubuntu
sudo dnf install flatpak flatpak-builder    # Fedora/RHEL

# Add Flathub (if not already added)
flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

# Install the GNOME SDK (or whichever runtime you'll use):
flatpak install org.gnome.Sdk//47
flatpak install org.gnome.Platform//47

# For KDE apps:
flatpak install org.kde.Sdk//6.8
flatpak install org.kde.Platform//6.8

# Build and install locally (--user = user installation, no root needed):
flatpak-builder --install --user --force-clean builddir com.example.MyApp.yaml

# Run it:
flatpak run com.example.MyApp

# Debug: drop into a shell inside the sandbox
flatpak run --command=bash com.example.MyApp

# Debug: inspect the sandbox from inside
cat /run/user/$(id -u)/flatpak/app/com.example.MyApp/.flatpak-info

# Rebuild just to check the manifest without installing:
flatpak-builder --force-clean builddir com.example.MyApp.yaml

# Check logs when something goes wrong:
journalctl -f --user  # In another terminal while running the app

# For Python apps (pip dependencies):
git clone https://github.com/flatpak/flatpak-builder-tools
cd flatpak-builder-tools/pip

python3 flatpak-pip-generator requests pillow numpy \
  --output python-deps.json

# Add to manifest:
# modules:
#   - python-deps.json
#   - name: myapp
#     ...

# 1. Test your manifest builds cleanly with no network errors:
flatpak-builder --force-clean --sandbox builddir com.example.MyApp.yaml

# 2. Fork github.com/flathub/flathub

# 3. Create com.example.MyApp/com.example.MyApp.yaml in your fork
#    (or com.example.MyApp/com.example.MyApp.json for JSON)

# 4. The Flathub CI will run automatically on your PR:
#    - Linting your manifest
#    - Building the app
#    - Running basic smoke tests
#    - Checking for common issues (network access during build, etc.)

# 5. Human reviewers check:
#    - App ID is appropriate
#    - Permissions are reasonable
#    - Sources are verifiable (no bare HTTP, commit hashes required)
#    - No proprietary bundled binaries for open-source apps

# 6. After approval, you get a dedicated repo under github.com/flathub/
#    Future updates: push to your app's repo, Flathub CI builds and publishes