Automatiser des transferts en CLI

Installer @coffrify/cli, s'authentifier, envoyer un transfert et exploiter la sortie JSON dans un cron ou une CI.

La CLI Coffrify met l'API REST v1 à portée de terminal. Avec la commande cof, vous créez un transfert chiffré, téléversez les fichiers et récupérez le lien de partage en une seule étape, sans écrire le moindre client HTTP. Cette recette montre comment l'installer, l'authentifier, envoyer un transfert depuis un script, puis brancher sa sortie JSON dans un pipeline automatisé (tâche planifiée, intégration continue). Tous les exemples sont reproductibles tels quels.

Installer la CLI

Le binaire s'appelle cof. Choisissez le canal d'installation selon vos habitudes : Homebrew, le script shell ou npm. Les trois installent exactement la même version. Vérifiez ensuite que cof répond avec cof --version.

brew install coffrify/tap/cof
 
cof --version
# @coffrify/cli 0.4.2

S'authentifier

Deux modes coexistent. En usage interactif, lancez cof login : la CLI affiche un code à six chiffres que vous validez dans votre console Coffrify, puis elle conserve la session localement. En usage non interactif (cron, CI, conteneur), passez plutôt une clé API par variable d'environnement, ce qui évite toute étape manuelle.

$ cof login
Ouvrez la console et saisissez ce code : 481 920
En attente de confirmation…
Connecté. Workspace actif : cabinet-lambert

Pour les scripts, exportez COFFRIFY_API_KEY avec une clé scopée. Créez une clé dédiée à l'automatisation (scope transfers:write suffit pour envoyer), de préférence restreinte, et stockez-la dans le gestionnaire de secrets de votre CI plutôt qu'en clair dans le dépôt. La CLI lit cette variable automatiquement, vous n'avez rien d'autre à configurer.

export COFFRIFY_API_KEY=cof_live_xxxxxxxxxxxxxxxxxxxx
 
# Pour vos essais, utilisez une clé de test :
# export COFFRIFY_API_KEY=cof_test_xxxxxxxxxxxxxxxxxxxx

Envoyer un transfert

La commande cof transfer create prend un ou plusieurs chemins de fichiers. La CLL déclare le transfert auprès de l'API, téléverse chaque fichier, puis renvoie le lien de partage. Les options reprennent les champs de l'API : --to pour le destinataire, --expires pour la durée de vie, et d'autres garde-fous décrits plus bas.

$ cof transfer create ./rapport.pdf --to=audit@kpmg.fr --expires=7d
✓ Transfert créé    TR-7QK2WD
✓ rapport.pdf       téléversé (2,4 Mo)
✓ Lien de partage   https://files.coffrify.com/TR-7QK2WD
  Expire le         2026-06-17

Les options les plus utiles en automatisation se mappent une à une sur le corps de POST /v1/transfers. En voici un aperçu pratique.

Option	Effet	Champ API
`--to`	Destinataire notifié par e-mail	`recipient`
`--expires`	Durée de vie (par exemple `7d`, `48h`)	`expires_in_hours`
`--max-downloads`	Nombre de téléchargements autorisés	`max_downloads`
`--password`	Protège l'accès par mot de passe	`password`
`--title`	Intitulé affiché du transfert	`transfer_title`
`--watermark`	Active le filigrane à la consultation	`watermark_enabled`

POST/v1/transfersEndpoint appelé par cof transfer create. Scope requis : transfers:write.

Exploiter la sortie JSON

Toutes les commandes acceptent l'option --json. La sortie devient alors une charge utile structurée, stable et versionnée selon semver, faite pour être analysée par un programme. Combinée à un outil comme jq, elle permet d'extraire le lien de partage ou l'identifiant du transfert pour la suite du pipeline.

# Créer un transfert et capturer le lien de partage
SHARE_URL=$(cof transfer create ./build/release.zip \
  --to=pilots@cabinet-lambert.fr \
  --expires=7d \
  --json | jq -r '.share_url')
 
echo "Disponible ici : $SHARE_URL"
# Disponible ici : https://files.coffrify.com/TR-7QK2WD

Recette : un script de cron

Le script suivant envoie chaque nuit le dernier export d'un dossier, échoue franchement si la clé manque ou si l'envoi rate, et journalise le lien obtenu. Déposez-le dans votre crontab avec la variable COFFRIFY_API_KEY fournie par l'environnement.

#!/usr/bin/env bash
set -euo pipefail
 
: "${COFFRIFY_API_KEY:?COFFRIFY_API_KEY manquante}"
 
LATEST=$(ls -t /exports/*.zip | head -n1)
 
RESULT=$(cof transfer create "$LATEST" \
  --to=comptabilite@client.fr \
  --title="Export nocturne" \
  --expires=72h \
  --max-downloads=3 \
  --json)
 
URL=$(echo "$RESULT" | jq -r '.share_url')
echo "$(date -Iseconds) envoyé : $URL" >> /var/log/coffrify-export.log

Recette : étape de CI

En intégration continue, deux approches sont possibles. La première installe cof puis l'appelle dans un job, la clé étant injectée comme secret de pipeline. La seconde s'appuie sur l'action GitHub officielle, qui enveloppe la CLI et expose les mêmes options sous forme de paramètres déclaratifs.

- name: Envoyer le build aux clients pilotes
  uses: coffrify/coffrify-action@v1
  with:
    token:         ${{ secrets.COFFRIFY_KEY }}
    files:         ./dist/*.zip
    recipients:    pilots@cabinet-lambert.fr
    expires_in:    7d
    fail_on_scan_infected: true

Vous disposez maintenant d'une chaîne complète : installation, authentification par clé scopée, envoi de transfert et lecture de la sortie JSON dans un cron ou une CI. La même mécanique s'étend aux autres familles de commandes (cof coffre, cof webhook, cof config), qui partagent l'option --json et les mêmes scopes que l'API. Pour les besoins ponctuels, la CLI reste interchangeable avec un appel REST direct : le contrat de POST /v1/transfers est strictement le même.