Client SSH de bureau · Windows / Linux / macOS

Connexions, terminal,
fichiers dans une seule fenêtre


LIULI Shell est un client SSH multiplateforme.
Il réunit la gestion des connexions, un terminal interactif, le transfert de fichiers SFTP, la surveillance de l'état d'exécution et la synchronisation de configuration dans une seule application de bureau, pour les développeurs et administrateurs système qui gèrent plusieurs serveurs.

Version installable / portable Synchronisation cloud multiplateforme Importe les sauvegardes FinalShell 8 thèmes d'interface
Fenêtre principale de LIULI Shell : serveurs et surveillance à gauche, terminal et fichiers au centre, informations du serveur et processus à droite
SessionsSSH multi-onglets avec reconnexion
FichiersConsultation et modification SFTP rapides
SurveillanceRessources, réseau et processus
SynchroService cloud officiel / WebDAV personnalisé
01 — Téléchargement

Choisissez votre mode d'installation

Windows 10 / 11 propose une version installable et une version portable ; Linux et macOS se compilent depuis les sources. Les deux versions Windows ont les mêmes fonctionnalités.

Installable et portable

La version installable inclut un assistant et crée des raccourcis ; la version portable fonctionne après extraction, idéale pour une clé USB ou un environnement temporaire.

Windows 10 / 11 x64 · Setup.exe / Portable.exe
Code YKXY (déjà inclus dans le lien, aucune saisie nécessaire)
Ouvrir 夸克网盘 ↗
GitHub

GitHub Releases

Adapté à l'accès depuis l'étranger ; les fichiers des versions suivent les commits du dépôt.

Voir les Releases GitHub ↗
Gitee

Gitee Releases

Adapté à l'accès depuis la Chine continentale ; fournit des fichiers portables, synchronisés avec le dépôt.

Voir les Releases Gitee ↗
Compiler depuis les sources

Linux / macOS

Installer les dépendances et générer le paquet sur le système cible : deb, AppImage, tar.gz, ainsi que dmg et zip pour macOS.

Voir les commandes de compilation
La configuration est enregistrée dans %APPDATA%\LIULI Shellpar défaut ; une mise à jour ou une réinstallation ne la supprime pas. Pour changer d'ordinateur, utilisez la synchronisation cloud ou exportez le fichier de configuration depuis les paramètres.
02 — Compilation

Générer les paquets depuis les sources

Linux et macOS doivent être compilés sur la machine cible. Exécutez les commandes une par une, sans coller tout le bloc. Le script identifie la distribution, installe les dépendances et demande le type de paquet.

build.sh — quick start copy & run
Quick Build

Commandes de compilation Linux / macOS

Choisissez d'abord une source (Gitee ou GitHub), puis entrez dans le dossier et lancez le script de compilation.
Gitee clone par défaut dans liuli-shell, GitHub dans Liulishell ; les commandes ci-dessous clonent dans liuli-shell, pour rester identiques par la suite.

Git est requis.Étape 0 : installer Git ; étape 1 : ne garder qu'une seule source ; étape 2 : lancer le script de compilation. Lancez la compilation une fois le clonage terminé.

# 0) Git requis ; ignoré s'il est déjà installé (dnf / pacman sur d'autres distributions)
command -v git >/dev/null || sudo apt-get update && sudo apt-get install -y git

# 1) Supprimer les anciens dossiers, puis cloner la source (Gitee ou GitHub)
# Gitee (recommandé en Chine ; dossier par défaut : liuli-shell)
rm -rf liuli-shell Liulishell && git clone https://gitee.com/liuliwanjiaweb/liuli-shell.git liuli-shell
# GitHub (recommandé à l'étranger ; dossier par défaut : Liulishell, ici liuli-shell)
rm -rf liuli-shell Liulishell && git clone https://github.com/LIULIWANJIA/Liulishell.git liuli-shell

# 2) Entrer dans le projet et compiler : détecter la distribution → dépendances système → choisir deb / AppImage → paquet → proposer l'installation
cd liuli-shell && bash scripts/build-linux.sh

Les fichiers sont générés dans dist/. Le script propose de choisir 1 = deb / 2 = AppImage / 3 = les deux ; pour ne générer que .tar.gz utilisez bash scripts/build-linux.sh tar. Le script gère automatiquement les *t64 de paquets sur Ubuntu 24.04+. Les environnements non interactifs comme la CI n'installent pas automatiquement : installez le paquet manuellement. En cas d'anomalie, lancez bash scripts/build-linux.sh check pour diagnostiquer ; le script bascule automatiquement de miroir si le téléchargement d'Electron est lent.

Si des dépendances manquent ou que la compilation échoue exécutez ces commandes dans l'ordre ; une compilation normale n'en a pas besoin
# 3) Si les dépendances manquent ou que la compilation échoue, essayer dans l'ordre
bash scripts/build-linux.sh repair
bash scripts/build-linux.sh deps
bash scripts/build-linux.sh

Les outils déjà installés sont ignorés.L'installation de Homebrew demande le mot de passe de l'utilisateur. Après le clonage, installez les dépendances et générez le paquet ; choisissez Intel ou Apple Silicon selon le besoin.

# Outils de base (ignorés si installés ; xcode-select ouvre une fenêtre, attendez la fin)
xcode-select --install 2>/dev/null || true
command -v brew >/dev/null || /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
# Ajouter Homebrew au PATH après installation (Intel : /usr/local/bin/brew)
if [ -x /opt/homebrew/bin/brew ]; then eval "$(/opt/homebrew/bin/brew shellenv)"; elif [ -x /usr/local/bin/brew ]; then eval "$(/usr/local/bin/brew shellenv)"; fi
# Node ≥ 18 requis ; installer 20 s'il manque ou est trop ancien, puis vérifier
node -v 2>/dev/null | grep -qE '^v(1[89]|[2-9][0-9])' || brew install node@20
brew link --overwrite --force node@20 >/dev/null 2>&1 || true
node -v && npm -v

# Supprimer les anciens dossiers, puis cloner la source (Gitee ou GitHub)
rm -rf liuli-shell Liulishell
# Gitee (recommandé en Chine ; dossier par défaut : liuli-shell)
git clone https://gitee.com/liuliwanjiaweb/liuli-shell.git liuli-shell
# GitHub (recommandé à l'étranger ; dossier par défaut : Liulishell, ici liuli-shell)
git clone https://github.com/LIULIWANJIA/Liulishell.git liuli-shell
cd liuli-shell npm ci || npm install # repli automatique sur npm install en cas d'échec npm run vendor # Si Electron se télécharge lentement depuis la Chine, décommentez les deux lignes suivantes (facultatif) # export ELECTRON_MIRROR=https://registry.npmmirror.com/-/binary/electron/ # export ELECTRON_BUILDER_BINARIES_MIRROR=https://registry.npmmirror.com/-/binary/electron-builder-binaries/ npm run dist:mac # x64 + arm64 ensemble npx electron-builder --mac dmg zip --arm64 # Apple Silicon uniquement

Les fichiers sont générés dans dist/(.dmg / .zip).npm run vendor copie les ressources xterm dans src/renderer/vendoravant la génération du paquet ; les fichiers Intel et Apple Silicon ne sont pas interchangeables. Si Gatekeeper bloque une application non signée, faites un clic droit sur « Ouvrir ».

Depuis la Chine, préférez Gitee ; si Electron se télécharge lentement, définissez une variable de miroir.

03 — Migration des données

Importer les sauvegardes FinalShell

L'import accepte les fichiers JSON exportés par FinalShell ou le dossier de configuration complet. L'import lit les informations de connexion, reconstruit la hiérarchie des groupes et affiche un récapitulatif avant l'écriture.

  • Deux sources possiblesSélectionnez plusieurs fichiers JSON à la fois, ou directement le dossier de configuration complet.
  • Hiérarchie restauréeLes groupes sont recréés selon l'arborescence d'origine, sur trois niveaux au maximum ; les dossiers plus profonds sont rattachés au groupe de premier niveau correspondant.
  • Gestion des mots de passeAprès déchiffrement, les mots de passe sont réenregistrés avec le chiffrement de l'application ; les entrées indéchiffrables restent vides avec un avertissement clair.
  • Écriture sécuriséeUn aperçu des groupes et connexions à créer est affiché avant l'import ; les doublons sont ignorés automatiquement et un échec ne modifie pas la configuration existante.
Importer la configuration FinalShell · LIULI Shell

Importer la configuration FinalShell

Déposez les fichiers ici ; vous pouvez sélectionner plusieurs JSON ou tout le dossier de configuration.

Déposer des fichiers JSON ou un dossier ou utilisez les boutons ci-dessous
Choisir des fichiers JSON Choisir un dossier
Prévision : créer 2 nouveaux groupes de premier niveau 3 nouveaux groupes de deuxième niveau 1 nouveaux groupes de troisième niveau, soit 14 configurations de serveur
Auto : import FinalShell (JSON direct)

Les dossiers créent des groupes selon la hiérarchie (trois niveaux au maximum) ; les JSON situés plus profond sont rattachés au groupe de premier niveau correspondant, quel que soit le groupe cible.

Lancer l'import Import terminé : 14 ajoutés, 2 doublons ignorés · Nouveaux groupes : 2 de premier niveau / 3 de deuxième / 1 de troisième
1Choisir la source Choisissez un ou plusieurs fichiers JSON FinalShell, ou tout le dossier de configuration.
2Vérifier le plan Les niveaux de groupes et le nombre de connexions à créer sont calculés automatiquement ; l'écriture a lieu après confirmation.
3Terminer l'import Écriture après dédoublonnage et rafraîchissement de la liste ; les nouveaux groupes sont repliés par défaut pour ne pas interrompre le travail.
04 — Échanges et retours

Obtenir de l'aide et les annonces de version

Questions d'usage, suggestions et actualités des versions sont partagées dans les groupes. Rejoignez la plateforme que vous utilisez.

Groupe QQ · Chine

Groupe QQ

Les utilisateurs en Chine peuvent signaler des problèmes et échanger sur la configuration et l'usage dans le groupe QQ.

1127112572
Rejoindre le groupe QQ ↗
Telegram · International

Groupe Telegram

Les utilisateurs hors de Chine retrouvent les mêmes annonces et discussions sur Telegram.

t.me/liulishell
Ouvrir le groupe Telegram ↗
05 — Modules principaux

Neuf modules pour l'exploitation quotidienne

De la connexion aux serveurs au transfert de fichiers, à la consultation de l'état et à la migration de configuration, l'essentiel se fait dans le client. Voici ce que fait chaque module.

01
▤

Gestion des serveurs

Organisez les serveurs en groupes, avec sélection multiple, déplacement par glisser-déposer et copie de configurations ; les connexions supprimées vont dans une corbeille de 30 jours, restaurables à tout moment.

02
❯_

Sessions de terminal

Chaque onglet est une session SSH indépendante, avec historique des commandes, saisie rapide, reconnexion et réorganisation des onglets par glisser-déposer ; les connexions via proxy affichent un indicateur d'état.

03
▥

Gestion des fichiers

L'arborescence SFTP et la liste des fichiers sont liées et suivent les changements de dossier du terminal ; envoi, téléchargement, modification des droits et éditeur de texte intégré.

04
◎

Surveillance en temps réel

Collecte continue du CPU, de la mémoire, du Swap, des disques, des cartes réseau et des processus ; les échelles des graphiques s'adaptent automatiquement, ce qui permet de repérer directement une charge anormale.

05
⇅

Centre de transfert

Les téléchargements sont gérés dans une fenêtre dédiée : pause, annulation ou vidage des tâches, avec progression, débit et état en temps réel.

06
☁

Synchronisation cloud

Prend en charge le service cloud officiel et un WebDAV personnalisé : synchronisation chiffrée des serveurs, groupes et favoris, fusion bidirectionnelle entre appareils ; synchronisation ou sauvegarde manuelle également possible.

07
⇄

Migration de configuration

Lit les sauvegardes JSON de FinalShell ou tout le dossier de configuration et reconstruit les groupes selon la hiérarchie d'origine ; aperçu avant import, doublons ignorés automatiquement.

08
◐

Apparence et interaction

8 thèmes clairs et sombres intégrés ; polices, tailles, zoom de l'interface, comportement de la souris et raccourcis sont réglables et enregistrés automatiquement.

09
⌁

Proxy réseau

Définissez un proxy HTTP / SOCKS5 par connexion ou globalement, avec proxy par défaut et repli en direct, pour les intranets et les réseaux restreints.

06 — Extraits

Commandes fréquentes, à portée de clic

Regroupez les commandes fréquentes par panneaux pour éviter de retaper de longues commandes ; les modifications se font ensuite dans l'éditeur de commandes.

Snippets & Command Editor

Organisés par panneaux, plus de saisie répétée

Les panneaux Courantes, Docker, Réseau et autres sont gérés séparément ; les boutons n'affichent que leur nom pour garder une interface épurée ; panneaux et commandes se réordonnent par glisser-déposer.

  • Mode d'exécutionExécution en un clic, ou saisie dans la zone de commande puis confirmation.
  • Éditeur de commandesLes scripts multilignes s'éditent à droite ; Ctrl + Entrée les envoie à la session active.
  • Historique et sessionBasculez entre l'historique des commandes et la session courante pour retrouver la dernière saisie.
ExtraitsSNIPPETS
CourantesDockerRéseau+
Utilisation du disqueUtilisation de la mémoireProcessusEffacer l'écran
Éditeur de commandes Ctrl + Enter
1docker compose pull
2docker compose up -d
3docker compose ps
07 — Surveillance en temps réel

Ressources, réseau et processus sur un seul écran

L'état d'exécution est collecté dès la connexion ; identifiez d'abord une charge anormale dans le client, puis décidez d'ouvrir un terminal.

Surveillance serveurLIVE · 2s
CPU64%
Mémoire62%
Swap14%
Descendant1.36 Mbps
Montant0.21 Mbps
Aperçu des processus Trié par CPU
nginx12.5%340 MB
worker-112.0%17.6 MB
worker-211.7%20.1 MB
worker-311.4%22.7 MB
Monitor & Processes

Voir l'état sans se connecter au serveur

Ressources à gauche, débit réseau et occupation des processus à droite ; l'intervalle de rafraîchissement et l'unité de débit se règlent dans les paramètres.

  • Vue des ressourcesUtilisation du CPU, de la mémoire, du Swap et des partitions disque ; les échelles des graphiques s'adaptent automatiquement.
  • Débit réseauDébit descendant / montant et trafic cumulé sur le même écran ; unité commutable.
  • Aperçu des processusTri par CPU ou mémoire pour retrouver rapidement les processus gourmands.
08 — Données et sécurité

La configuration reste locale, les modifications sont sauvegardées

Identifiants, sauvegardes de configuration et restauration des suppressions se font dans le client, avec moins de dépendance à des services externes ou à des manipulations manuelles.

Local Data & Security

Mots de passe chiffrés, suppressions récupérables

Les identifiants ne sont stockés que sous forme chiffrée et jamais affichés en clair ; la configuration est sauvegardée avant écriture et les serveurs ou groupes supprimés vont dans la corbeille.

  • Protection des identifiantsLes mots de passe et les clés sont chiffrés avec une clé locale ; un mot de passe peut être ajouté à l'export de la configuration.
  • Sauvegarde automatiqueUne sauvegarde est créée avant chaque écriture ; en cas de fichier de configuration corrompu, restaurez la plus récente.
  • CorbeilleLes serveurs et groupes supprimés sont conservés 30 jours et restaurables à tout moment.
Données et sécuritéLOCAL
✓
Identifiants chiffrésLes mots de passe et les clés ne sont stockés que sous forme chiffrée, jamais en clair dans l'interface.
✓
Sauvegarde automatique avant écritureEn cas de fichier de configuration corrompu, restaurez la dernière sauvegarde.
✓
Corbeille de 30 joursLes serveurs et groupes supprimés par erreur sont restaurables à tout moment.
✓
Export / import chiffréLors d'un changement d'ordinateur, exportez la configuration avec un mot de passe.
09 — Organisation de l'interface

La fenêtre principale comporte trois colonnes

La largeur des trois colonnes se règle par glisser-déposer et chacune peut être masquée ; en haut, les onglets de session et les contrôles de fenêtre, en bas, la barre d'état indique le nombre de connexions actives.

Gauche Serveurs et surveillance.Liste des groupes, recherche, état des connexions, ainsi que les aperçus CPU, mémoire, Swap et disque.
Centre Zone de travail.Terminal SSH, saisie de commandes, gestionnaire de fichiers et panneau d'extraits.
Droite Détails de la connexion.Informations du serveur, débit réseau, liste des processus et éditeur de commandes.
Zone de terminal avec la colonne de droite masquée
Zone de terminalMasquez la colonne de droite pour agrandir le terminal
Centre de paramètres
ParamètresThèmes, polices, zoom et options de données
Panneau d'extraits
ExtraitsOrganisés par panneaux, prêts à exécuter
Langues

Huit langues pour l'application et le site

L'interface du client et ce site sont disponibles en chinois simplifié, chinois traditionnel, anglais, russe, français, allemand, japonais et coréen. Le changement de langue met à jour l'adresse de la page et les balises hreflang ; chaque langue reprend les mêmes fonctionnalités et les mêmes captures d'écran.

简体中文Chinese (Simplified) · zh-CN
繁體中文Chinese (Traditional) · zh-Hant
EnglishEnglish · en
日本語Japanese · ja
한국어Korean · ko
РусскийRussian · ru
FrançaisFrench · fr
DeutschGerman · de
10 — Paramètres et thèmes

Adaptez l'application à votre façon de travailler

Les paramètres sont regroupés par usage et enregistrés automatiquement. Voici les six groupes les plus utilisés.

LIULI Shell · Paramètres
Paramètres de LIULI Shell
Le menu de gauche regroupe les paramètres par usage ; à droite s'affichent les options de la catégorie courante ; en bas, restauration des paramètres par défaut.

Apparence et thèmes

  • 8 palettes ; le fond du terminal et les couleurs ANSI changent en même temps
  • Largeur des colonnes et hauteur du bas mémorisées après glisser-déposer
  • Les panneaux inutiles peuvent être masqués individuellement

Polices et zoom

  • Polices latin / CJK, taille et interligne réglés séparément
  • Zoom de l'interface 100 / 125 / 150 / 200%
  • Le changement de zoom demande une confirmation ;Ctrl+Shift+0 réinitialise

Souris et raccourcis

  • Comportement du clic central et du clic droit dans le terminal réglable
  • Les raccourcis globaux sont modifiables ; les conflits sont signalés immédiatement
  • Les extraits se réordonnent par glisser-déposer

Extraits

  • Organiser les commandes fréquentes par panneaux
  • La zone de contrôle reste sur la première ligne ; les panneaux passent à la ligne si nécessaire
  • Exécution en simple ou double clic

Synchronisation et proxy

  • Adresse WebDAV, compte et identifiants enregistrés séparément
  • Fusion bidirectionnelle des configurations, groupes et favoris
  • Proxy HTTP / SOCKS5, avec proxy par défaut configurable

Données et sécurité

  • Sauvegarde automatique avant écriture, restauration si besoin
  • Mots de passe et clés stockés chiffrés, jamais en clair dans l'interface
  • L'effacement des données nécessite une confirmation et un compte à rebours
Themes

8 palettes de thèmes

6 thèmes clairs et 2 sombres ; l'interface, le fond du terminal et les couleurs ANSI changent ensemble.

Blanc chaud · Vert encrePar défaut · reposant pour les yeux
Bleu brume · Indigotons froids et nets
Beige amande · Terre cuitechaleur papier
Graphite · Gris froidneutre à fort contraste
Nuit · Encre profondeinterface sombre
Rose poudré · Pruneviolet chaud et doux
Céladon · Vert pinvert d'eau discret
Mer profonde · Bleu indigotons bleus sombres
11 — Référence avancée

Compilation manuelle et dépannage

Dépliez la référence complète pour contrôler manuellement la compilation, préparer les dépendances d'une distribution ou diagnostiquer une erreur de paquet.

Guide complet de compilation Linux / macOS Commandes de dépendances par distribution, paquets AppImage / deb / dmg, icônes de bureau, gestion de FUSE et correspondance des erreurs courantes. ▾

Linux x64 (AppImage / .deb / tar.gz)

Le nom des bibliothèques système varie selon la distribution ; depuis Ubuntu 24.04, c'est *t64. Usages des trois paquets : AppImage sans installation, deb via le gestionnaire de paquets, tar.gz utilisable après extraction sans dépendre de FUSE.

Compatibilité : AppImage ne s'exécute que sur des systèmes dont la glibc n'est pas plus ancienne que celle de la machine de compilation. Pour une compatibilité 20.04 ~ 26.04, compilez sur la plus ancienne, Ubuntu 20.04 ; le scripts/build-linux.sh du dépôt détecte la distribution et gère le repli vers les noms t64.
Pas envie d'installer les dépendances à la main :bash scripts/build-linux.sh une seule commande fait « détecter la distribution → installer les dépendances → choisir le type de paquet → générer → proposer l'installation », compatible apt / dnf / pacman. Pour les dépendances seules, utilisez ... deps, pour le diagnostic seul ... check, en cas d'environnement cassé ... repair. À l'installation : deb passe par apt install et crée les icônes de bureau ; AppImage est copié dans ~/Applications/LIULI-Shell avec une entrée de menu et une icône de bureau.

Exécution et installation

chmod +x dist/LIULI-Shell-*-x86_64.AppImage
./dist/LIULI-Shell-*-x86_64.AppImage

# Installer le deb sur Debian / Ubuntu
sudo apt install ./dist/LIULI-Shell-*_amd64.deb

# Extraire et exécuter (sans FUSE, sans écrire dans les dossiers système)
mkdir -p ~/Applications
tar -xzf dist/LIULI-Shell-*-x86_64.tar.gz -C ~/Applications
~/Applications/LIULI-Shell-*/liulishell

Erreur AppImage : dlopen(): error loading libfuse.so.2

AppImage utilise le runtime type-2 et nécessite FUSE 2. Ubuntu 22.04 et antérieurs l'incluent ; 24.04 / 26.04 demandent une installation manuelle. Sans FUSE, une exécution après extraction reste possible.

# Ubuntu 24.04 / 26.04
sudo apt install -y libfuse2t64
# Ubuntu 20.04 / 22.04, Debian 12
sudo apt install -y libfuse2

# Exécuter sans FUSE (démarrage un peu plus lent, mêmes fonctionnalités)
./LIULI-Shell-*-x86_64.AppImage --appimage-extract-and-run

# Ou utiliser le paquet tar.gz, sans aucune dépendance à FUSE
Ajouter l'icône au menu / au bureau (AppImage)
# 1) Placer dans un dossier fixe
mkdir -p ~/Applications
cp dist/LIULI-Shell-*-x86_64.AppImage ~/Applications/LIULI-Shell.AppImage
chmod +x ~/Applications/LIULI-Shell.AppImage

# 2) Extraire les icônes (--appimage-extract crée squashfs-root dans le dossier courant)
cd /tmp && ~/Applications/LIULI-Shell.AppImage --appimage-extract '*.png' >/dev/null 2>&1
mkdir -p ~/.local/share/icons/hicolor/512x512/apps
cp /tmp/squashfs-root/*.png ~/.local/share/icons/hicolor/512x512/apps/liulishell.png 2>/dev/null \
  || cp /tmp/squashfs-root/liulishell.png ~/.local/share/icons/hicolor/512x512/apps/ 2>/dev/null

# 3) Écrire l'entrée de menu ($HOME sera remplacé par le dossier de l'utilisateur)
mkdir -p ~/.local/share/applications
cat > ~/.local/share/applications/LiuliShell.desktop <<EOF
[Desktop Entry]
Type=Application
Name=LIULI Shell
Comment=Client SSH multiplateforme et gestionnaire de serveurs
Exec=$HOME/Applications/LIULI-Shell.AppImage %U
Icon=liulishell
Terminal=false
Categories=Development;System;Network;
StartupWMClass=LiuliShell
EOF
chmod +x ~/.local/share/applications/LiuliShell.desktop
update-desktop-database ~/.local/share/applications 2>/dev/null || true

# 4) Pour une icône de bureau, en copier une et la marquer de confiance
cp ~/.local/share/applications/LiuliShell.desktop ~/Desktop/
gio set ~/Desktop/LiuliShell.desktop metadata::trusted true 2>/dev/null || true
# Sur un système localisé, le dossier du bureau peut être ~/Bureau : adaptez si besoin

Les utilisateurs du .deb n'ont pas besoin de ces étapes : l'installation écrit automatiquement /usr/share/applications, l'application apparaît directement dans le menu.

macOS (dmg + zip, x64 / arm64)

Prérequis :macOS 12+ (Intel ou Apple Silicon), Xcode Command Line Tools, Homebrew, Git, Node.js 20/22 LTS. Le dmg ne peut pasêtre compilé sous Windows / Linux.

1. Outils de base(xcode-select ouvre une fenêtre, attendez la fin de l'installation)

xcode-select --install
/bin/bash -c "$(curl -fsSL \
  https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Ajouter brew au PATH sur Apple Silicon (Intel : /usr/local/bin/brew ; relançable sans doublon)
grep -qsF 'brew shellenv' ~/.zshrc || echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zshrc
source ~/.zshrc

2. Node 20 et Git

brew install node@20 git
brew link --overwrite --force node@20
node -v && npm -v          # attendu : v20.x

3. Sources et dépendances(supprimez d'abord les anciens dossiers pour éviter les fichiers résiduels ; choisissez Gitee ou GitHub. Gitee clone par défaut dans liuli-shell, GitHub dans Liulishell, ici cloné explicitement dans liuli-shell)

rm -rf liuli-shell Liulishell
# Gitee (recommandé en Chine)
git clone https://gitee.com/liuliwanjiaweb/liuli-shell.git liuli-shell
# GitHub (recommandé à l'étranger ; décommentez la ligne suivante et commentez celle de Gitee)
# git clone https://github.com/LIULIWANJIA/Liulishell.git liuli-shell
cd liuli-shell
npm ci || npm install      # repli sur npm install si le fichier de verrouillage ne correspond pas
npm run vendor             # copie les ressources xterm dans src/renderer/vendor avant la génération du paquet

4. Génération du paquet(l'architecture courante est la plus rapide ; pour les deux, passez dist:mac)

npm run dist:mac                              # x64 + arm64 ensemble
npx electron-builder --mac dmg zip --arm64    # Apple Silicon uniquement
npx electron-builder --mac dmg zip --x64      # Intel uniquement

5. Fichiers et cache :Les fichiers sont générés dans ~/liuli-shell/dist/(*.dmg,*.zip) ; les caches de téléchargement d'Electron et des outils de paquet sont dans ~/Library/Caches/electron/et~/Library/Caches/electron-builder/ ; les supprimer force un nouveau téléchargement.

6. Installation non signée :Si Gatekeeper bloque l'application après l'avoir déposée dans « Applications », faites un clic droit sur « Ouvrir », ou exécutez :

xattr -dr com.apple.quarantine "/Applications/LIULI Shell.app"
spctl --assess --type execute -vv "/Applications/LIULI Shell.app"   # voir la raison du blocage

La distribution publique nécessite un certificat Apple Developer ID et une notarisation : configurez CSC_LINK(chemin ou base64 du .p12),CSC_KEY_PASSWORD ; la notarisation demande aussi APPLE_ID,APPLE_APP_SPECIFIC_PASSWORD,APPLE_TEAM_ID ; electron-builder effectue la signature et la notarisation.

Les paquets Intel et Apple Silicon ne sont pas interchangeables ; pour couvrir les deux machines avec un seul paquet, utilisez npx electron-builder --mac dmg --universal(environ le double de la taille d'une architecture, et une compilation nettement plus lente).

Tableau des erreurs courantes

Erreur / symptômeCause et traitement
Impossible de localiser le paquet libasound2 Depuis Ubuntu 24.04 / Debian 13, les bibliothèques système sont renommées *t64(par ex. libasound2t64,libgtk-3-0t64). Installez d'abord l'ancien nom, avec repli automatique :bash scripts/build-linux.sh deps intègre déjà cette logique.
dlopen(): error loading libfuse.so.2 AppImage nécessite FUSE 2 à l'exécution : sur 24.04+ installez libfuse2t64, sur 22.04 et antérieurs libfuse2 ; sans FUSE, utilisez --appimage-extract-and-run, ou passez à .tar.gz.
Téléchargement d'Electron expiré / bloqué sur downloading Définissez un miroir puis réessayez :export ELECTRON_MIRROR=https://registry.npmmirror.com/-/binary/electron/,export ELECTRON_BUILDER_BINARIES_MIRROR=https://registry.npmmirror.com/-/binary/electron-builder-binaries/.
Échec de npm ci / fichier de verrouillage incompatible Supprimez node_modules puis utilisez npm install ; un Node trop ancien (< 18) ne s'installe pas, passez à Node 20.
rpmbuild not found Nécessaire seulement pour le rpm : sur Fedora installez rpm-build, sur Debian/Ubuntu rpm et rpm2cpio paquets, ou ignorez la cible rpm.
Permission denied (exécution d'AppImage) Droit d'exécution manquant :chmod +x dist/LIULI-Shell-*-x86_64.AppImage.
errSecInternalComponent / échec de signature (macOS) keychain est verrouillé :security unlock-keychain -p <mot de passe> ~/Library/Keychains/login.keychain-db puis relancez ; sur CI, ajoutez aussi security set-key-partition-list.

Remarques générales

  • Dossier de compilation :tous les paquets sont générés par défaut dans dist/à la racine du projet. Sous Linux, LIULI-Shell-*-x86_64 / *-arm64 de .AppImage / .deb / .tar.gz(le script détecte l'architecture) ; sous macOS, .dmg / .zip.
  • Avant la génération du paquet :npm run vendor copie les ressources frontend comme xterm.js dans src/renderer/vendor/ ; sans cette étape, le terminal du paquet reste vide.
  • Choix de la machine de compilation :AppImage ne s'exécute que sur des systèmes dont la glibc n'est pas plus ancienne que celle de la machine de compilation. Pour une compatibilité 20.04 ~ 26.04, compilez sur Ubuntu 20.04 ; pour un usage personnel, la compilation locale est la plus rapide.
  • Compilation croisée :les paquets Linux se compilent sous Linux et les paquets macOS sous macOS ; les paquets ne sont pas interchangeables, de même pour Windows. Utilisez de préférence une CI du système concerné (par ex. ubuntu-22.04,macos-14 runner) pour générer les paquets.
  • Publication :téléversez dans dist/ les paquets d'installation et portables de la plateforme concernée comme fichiers de Release (sous Windows, *.blockmap sert uniquement aux mises à jour différentielles, inutile de le téléverser) ; ne commitez pas dans le dépôt de sources node_modules/ et dist/.