CLI TeamDay

Le CLI TeamDay est une interface en ligne de commande puissante pour gérer les agents, exécuter des tâches, suivre le travail et automatiser les workflows directement depuis votre terminal.

Table des matières

• Installation
• Authentification
• Gestion des agents
• Travail avec les espaces
• Gestion des tâches
• Suivi des exécutions
• Configuration
• Automatisation
• Référence des commandes

Installation

Prérequis

• Node.js 18+ ou Bun 1.0+
• Un compte TeamDay sur teamday.ai

Installation depuis la source (actuellement)

cd /path/to/teamday/packages/cli
bun install
bun link

Vérifier l'installation :

teamday --version

Mettre à jour le CLI

cd /path/to/teamday/packages/cli
git pull
bun install

Authentification

Connexion OAuth (recommandée)

Authentification interactive basée sur le navigateur avec gestion automatique des tokens :

teamday auth login

Ce qui se passe :

1. Le CLI génère un code d'autorisation sécurisé
2. Ouvre votre navigateur sur la page de connexion TeamDay
3. Vous cliquez sur "Autoriser CLI"
4. Le CLI reçoit automatiquement les tokens OAuth
5. Les tokens sont sauvegardés de manière sécurisée dans ~/.teamday/

Nouveaux utilisateurs : Si vous n'avez pas encore d'organisation, une sera créée automatiquement lors de l'autorisation du CLI.

Vérifier le statut d'authentification

teamday auth status

Sortie :

✓ Authentifié

Méthode : oauth
ID utilisateur : abc123xyz
Organisation : org_456def
Expire : dans 12 minutes

Rafraîchir le token

Les tokens OAuth expirent après 15 minutes. Rafraîchir manuellement :

teamday auth refresh

Note : Les tokens de rafraîchissement durent 90 jours. Après cela, exécutez à nouveau teamday auth login.

Déconnexion

Effacer les identifiants stockés :

teamday auth logout

Personal Access Token (alternative)

Pour l'automatisation et le CI/CD, utilisez des PAT au lieu d'OAuth :

teamday auth set-key "td_your_token_here"

Ou utilisez une variable d'environnement :

export TEAMDAY_API_TOKEN="td_your_token_here"

Voir le Guide des clés API pour créer des PAT dans l'application web.

Gestion des agents

Lister tous les agents

teamday agents list

Sortie :

┌──────────────────────┬────────────────┬───────────────┬────────────────────┬────────────┐
│ id                   │ name           │ role          │ systemPrompt       │ visibility │
├──────────────────────┼────────────────┼───────────────┼────────────────────┼────────────┤
│ char_abc123          │ Joe            │ Assistant     │ You are helpful... │ private    │
│ char_def456          │ Code Reviewer  │ Developer     │ Review code for... │ private    │
└──────────────────────┴────────────────┴───────────────┴────────────────────┴────────────┘

Total : 2 agent(s)

Formats de sortie :

# Tableau (par défaut)
teamday agents list

# JSON pour le scripting
teamday agents list --format json

# YAML pour la lisibilité
teamday agents list --format yaml

Obtenir les détails d'un agent

teamday agents get char_abc123

Affiche la configuration complète de l'agent incluant :

• Le prompt système
• La configuration du modèle
• Les outils avancés activés
• Les horodatages de création/mise à jour
• Les paramètres d'avatar et de couleur

Créer un agent

Création basique :

teamday agents create \
  --name "Mon Assistant" \
  --role "Aide" \
  --system-prompt "Vous êtes un assistant IA utile"

Options avancées :

teamday agents create \
  --name "Réviseur de code" \
  --role "Développeur senior" \
  --system-prompt "$(cat prompts/code-review.txt)" \
  --model "claude-3-5-sonnet-20241022" \
  --visibility private

Sortie :

✅ Agent créé :
   ID : char_xyz789
   Nom : Réviseur de code
   Statut : actif

Mettre à jour un agent

teamday agents update char_abc123 \
  --name "Nom mis à jour" \
  --role "Nouveau rôle"

Mettre à jour le prompt système depuis un fichier :

teamday agents update char_abc123 \
  --system-prompt "$(cat nouveau-prompt.txt)"

Supprimer (archiver) un agent

teamday agents delete char_abc123

Sortie :

✅ Agent archivé

   Note : L'agent est archivé, pas supprimé définitivement

Agents archivés :

• N'apparaissent plus dans les listes
• Ne peuvent pas être exécutés
• L'historique d'exécution est préservé
• Peuvent être restaurés dans l'application web

Exécuter un agent

teamday agents exec char_abc123 "Combien font 2+2 ?"

Avec streaming (par défaut) :

teamday agents exec char_abc123 \
  "Révise le code d'authentification" \
  --space s-project123 \
  --stream

Sans streaming :

teamday agents exec char_abc123 \
  "Question rapide" \
  --no-stream

Options :

• --space <id> - Exécuter dans le contexte d'un espace de travail
• --session <id> - Continuer une conversation existante
• --stream / --no-stream - Temps réel vs batch
• --timeout <ms> - Temps d'exécution maximum (défaut : 300000)

Chat interactif

Démarrer une conversation avec un agent :

teamday agents chat char_abc123

Fonctionnalités :

• Conversations multi-tours
• Réponses en streaming
• Persistance de session
• Sortie avec Ctrl+C ou tapez exit

Travail avec les espaces

Les espaces sont des environnements de travail où les agents peuvent accéder aux fichiers, aux dépôts git et collaborer sur des projets.

Lister les espaces

teamday spaces list

Sortie :

┌──────────────────────┬────────────────┬─────────────┬────────────┐
│ id                   │ name           │ visibility  │ members    │
├──────────────────────┼────────────────┼─────────────┼────────────┤
│ s-abc123             │ Backend API    │ private     │ user_xyz   │
│ s-def456             │ Site Marketing │ organization│ user_xyz   │
└──────────────────────┴────────────────┴─────────────┴────────────┘

Total : 2 espace(s)

Créer un espace

Espace de travail vide :

teamday spaces create \
  --name "Mon Projet" \
  --description "Développement API Backend" \
  --visibility private \
  --type empty

Options de visibilité :

• private - Vous seul pouvez y accéder
• organization - Tous les membres de l'organisation peuvent y accéder
• public - Toute personne avec le lien peut le voir

Sortie :

✅ Espace créé :
   ID : s-new123
   Nom : Mon Projet

Obtenir les détails d'un espace

teamday spaces get s-abc123

Affiche :

• Les métadonnées de l'espace
• Les couleurs de dégradé (pour l'interface)
• Le propriétaire et les membres
• Les horodatages de création/mise à jour

Supprimer un espace

teamday spaces delete s-abc123

Note : Seuls les propriétaires d'espace peuvent supprimer. L'espace est archivé (suppression douce), pas supprimé définitivement.

Gestion des tâches

Les tâches sont des éléments de travail que les agents créent pour déléguer du travail ou suivre des processus en plusieurs étapes.

Qu'est-ce que les tâches ?

Les tâches dans TeamDay sont créées par les agents pour :

• Déléguer du travail à d'autres agents
• Suivre des processus en plusieurs étapes
• Organiser des workflows complexes
• Maintenir la responsabilité

Exemple : Un agent construisant une fonctionnalité pourrait créer des tâches :

• "Réviser le code d'authentification" → Assigné à l'agent de révision de code
• "Écrire des tests unitaires" → Assigné à l'agent de test
• "Mettre à jour la documentation" → Assigné à l'agent de documentation

Lister les tâches

teamday tasks list

Sortie :

┌────────────────────┬────────────────────┬─────────────┬──────────┐
│ id                 │ title              │ status      │ priority │
├────────────────────┼────────────────────┼─────────────┼──────────┤
│ task_123           │ Réviser PR #456    │ pending     │ high     │
│ task_124           │ Mettre à jour docs │ in_progress │ medium   │
└────────────────────┴────────────────────┴─────────────┴──────────┘

Total : 2 tâche(s)

Filtrer par statut :

teamday tasks list --status pending
teamday tasks list --status in_progress
teamday tasks list --status completed

Filtrer par assigné :

teamday tasks list --assigned-to char_abc123

Filtrer par espace :

teamday tasks list --space s-project123

Créer une tâche

teamday tasks create \
  --title "Réviser le rapport T4" \
  --description "Analyser les données de ventes T4 et créer un résumé" \
  --priority high

Avec assignation :

teamday tasks create \
  --title "Révision de code" \
  --description "Réviser PR #123" \
  --assigned-to char_reviewer \
  --priority medium \
  --space s-codebase

Propriétés de tâche :

• title - Requis, description courte
• description - Optionnel, contexte détaillé
• priority - low|medium|high|urgent (défaut : medium)
• assignedTo - ID de l'agent auquel assigner la tâche
• spaceId - Contexte d'espace pour la tâche

Sortie :

✅ Tâche créée :
   ID : task_456
   Titre : Réviser le rapport T4
   Statut : pending

Obtenir les détails d'une tâche

teamday tasks get task_123

Affiche les informations complètes de la tâche incluant la date de création, la date de complétion (si complétée) et toutes les métadonnées.

Mettre à jour une tâche

teamday tasks update task_123 \
  --status in_progress \
  --assigned-to char_different

Options de statut :

• pending - Pas commencée
• in_progress - En cours de traitement
• completed - Terminée
• cancelled - Abandonnée

Compléter une tâche

Commande rapide pour marquer une tâche comme terminée :

teamday tasks complete task_123

Annuler une tâche

teamday tasks cancel task_123

Suivi des exécutions

Suivez les exécutions d'agents, consultez l'historique et surveillez les agents en cours d'exécution.

Lister les exécutions

teamday executions list

La sortie affiche :

• ID d'exécution
• ID de l'agent
• Message/prompt
• Statut (running, completed, failed, cancelled)
• Durée
• Horodatages

Filtrer par statut :

teamday executions list --status running
teamday executions list --status completed

Obtenir les détails d'une exécution

teamday executions get exec_abc123

Affiche :

• Métadonnées complètes d'exécution
• ID de chat/session
• Profondeur de délégation (pour les workflows multi-agents)
• Heures de début et de complétion

Annuler une exécution

Arrêter un agent en cours d'exécution :

teamday executions cancel exec_abc123

Configuration

Voir la configuration

# Tous les paramètres
teamday config list

Sortie :

┌──────────────────────────────┬──────────────────────────┐
│ api_url                      │ http://localhost:3000    │
├──────────────────────────────┼──────────────────────────┤
│ format                       │ table                    │
├──────────────────────────────┼──────────────────────────┤
│ no_color                     │ false                    │
├──────────────────────────────┼──────────────────────────┤
│ timeout                      │ 300000                   │
├──────────────────────────────┼──────────────────────────┤
│ verbose                      │ false                    │
└──────────────────────────────┴──────────────────────────┘

Fichier de config : /Users/you/.teamday/config.json

Obtenir une valeur spécifique :

teamday config get format

Mettre à jour les paramètres

# Format de sortie
teamday config set format json  # ou : table, yaml

# URL de l'API (pour auto-hébergé)
teamday config set api_url https://your-instance.com

# Timeout de requête (millisecondes)
teamday config set timeout 600000  # 10 minutes

# Sortie détaillée
teamday config set verbose true

Réinitialiser les paramètres

# Réinitialiser un paramètre spécifique
teamday config unset format

# Réinitialiser tous aux valeurs par défaut
teamday config reset

Variables d'environnement

Remplacer la configuration avec des variables d'environnement :

export TEAMDAY_API_URL=http://localhost:3000
export TEAMDAY_API_TOKEN=td_your_token
export TEAMDAY_FORMAT=json
export TEAMDAY_NO_COLOR=1
export TEAMDAY_TIMEOUT=600000
export TEAMDAY_VERBOSE=true

Les variables d'environnement ont la priorité sur les paramètres du fichier de configuration.

Automatisation

Scripts shell

Résumé quotidien des tâches :

#!/bin/bash
# daily-tasks.sh

echo "Résumé des tâches - $(date +%Y-%m-%d)"
echo "================================"

echo -e "\n📋 Tâches en attente :"
teamday tasks list --status pending --format json | \
  jq -r '.[] | "\(.title) (Priorité : \(.priority))"'

echo -e "\n✅ Complétées aujourd'hui :"
teamday tasks list --status completed --format json | \
  jq -r '.[] | "\(.title)"'

Rendre exécutable et exécuter :

chmod +x daily-tasks.sh
./daily-tasks.sh

Planifié avec cron :

# Envoyer un résumé quotidien par email à 9h
0 9 * * * /path/to/daily-tasks.sh | mail -s "Tâches quotidiennes" [email protected]

Intégration CI/CD

GitHub Actions :

name: Vérification des tâches d'agent

on: [push]

jobs:
  check-tasks:
    runs-on: ubuntu-latest
    steps:
      - name: Installer le CLI TeamDay
        run: |
          cd /tmp
          git clone https://github.com/yourorg/teamday.git
          cd teamday/packages/cli
          bun install
          bun link

      - name: Vérifier les tâches en attente
        env:
          TEAMDAY_API_TOKEN: ${{ secrets.TEAMDAY_TOKEN }}
        run: |
          pending=$(teamday tasks list --status pending --format json | jq 'length')
          echo "Tâches en attente : $pending"
          if [ $pending -gt 10 ]; then
            echo "⚠️  Attention : Plus de 10 tâches en attente !"
          fi

Opérations par lots

Créer plusieurs tâches depuis un CSV :

#!/bin/bash
# import-tasks.sh

while IFS=, read -r title description priority assignee; do
  teamday tasks create \
    --title "$title" \
    --description "$description" \
    --priority "$priority" \
    --assigned-to "$assignee"
done < tasks.csv

Exporter les données pour analyse :

#!/bin/bash
# export-execution-data.sh

# Obtenir toutes les exécutions en JSON
teamday executions list --format json > executions.json

# Analyser avec jq
cat executions.json | jq '
  group_by(.status) |
  map({status: .[0].status, count: length})
'

Référence des commandes

Options globales

Disponibles sur toutes les commandes :

--help, -h         Afficher l'aide
--version, -V      Afficher la version
--format <format>  Format de sortie (table|json|yaml)
--api-url <url>    Remplacer l'endpoint API
--verbose          Afficher la sortie détaillée
--no-color         Désactiver la sortie colorée

auth

Commandes d'authentification :

agents

Gestion des agents :

Options de liste :

• --status <active|archived>
• --visibility <private|organization|public>
• --tag <tag>
• --format <table|json|yaml>

Options de création :

• --name <name> (requis)
• --role <role>
• --system-prompt <prompt> (requis)
• --model <model> (défaut : claude-3-5-sonnet-20241022)
• --visibility <private|organization|public> (défaut : private)

Options d'exécution :

• --space <id> - Exécuter dans un espace de travail
• --session <id> - Continuer une session
• --stream / --no-stream - Mode streaming
• --timeout <ms> - Temps d'exécution maximum

spaces

Gestion des espaces de travail :

Options de création :

• --name <name> (requis)
• --description <desc>
• --visibility <private|organization|public> (défaut : private)
• --type <empty|git|starterKit> (défaut : empty)

tasks

Gestion des tâches :

Options de liste :

• --status <pending|in_progress|completed|cancelled>
• --assigned-to <agent-id>
• --space <space-id>
• --priority <low|medium|high|urgent>

Options de création :

• --title <title> (requis)
• --description <desc>
• --assigned-to <agent-id>
• --priority <low|medium|high|urgent> (défaut : medium)
• --space <space-id>

executions

Suivi des exécutions :

Options de liste :

• --status <pending|running|completed|failed|cancelled>
• --agent <agent-id>

config

Gestion de la configuration :

Clés disponibles :

• api_url - URL de l'endpoint API
• format - Format de sortie (table|json|yaml)
• no_color - Désactiver les couleurs (true|false)
• timeout - Timeout de requête en millisecondes
• verbose - Sortie détaillée (true|false)

Astuces et conseils

Sortie JSON pour le scripting

# Obtenir l'ID d'un agent programmatiquement
agent_id=$(teamday agents list --format json | jq -r '.[0].id')

# Compter les tâches en attente
pending=$(teamday tasks list --status pending --format json | jq 'length')
echo "Tâches en attente : $pending"

# Extraire les ID d'exécution
teamday executions list --format json | jq -r '.[].id' | \
  while read exec_id; do
    echo "Traitement : $exec_id"
  done

Combiner les commandes

# Créer une tâche pour chaque exécution en attente
teamday executions list --status running --format json | \
  jq -r '.[] | "\(.id),\(.message)"' | \
  while IFS=, read -r exec_id message; do
    teamday tasks create \
      --title "Réviser l'exécution $exec_id" \
      --description "$message"
  done

Débogage

# Sortie détaillée
teamday --verbose agents list

# Voir la configuration complète
teamday config list

# Vérifier l'authentification
teamday auth status

# Tester la connexion
teamday --api-url http://localhost:3000 agents list

Résolution de problèmes

Problèmes d'authentification

Problème : Erreurs 401 Unauthorized

Solutions :

# Vérifier le statut d'authentification
teamday auth status

# Rafraîchir le token
teamday auth refresh

# Se réauthentifier
teamday auth logout
teamday auth login

Erreurs de connexion

Problème : Cannot connect to API

Solutions :

# Vérifier l'URL de l'API
teamday config get api_url

# Mettre à jour si nécessaire
teamday config set api_url http://localhost:3000

# Tester avec une URL explicite
teamday --api-url http://localhost:3000 agents list

Erreurs d'exécution d'agent

Problème : 501 Server Error lors de l'exécution des agents

Causes possibles :

• Aucune clé API Anthropic configurée (niveau utilisateur, org ou serveur)
• Problème de sélection du niveau d'authentification

Solution : Assurez-vous d'avoir une clé API configurée :

# Vérifier le statut d'authentification
teamday auth status

# Option 1 : Ajouter une clé API dans l'application web (Paramètres → Intégrations)
# Option 2 : Contacter l'administrateur pour configurer la clé API du serveur

Organisation introuvable

Problème : organizationId: undefined à la première connexion

Solution : Le CLI crée automatiquement une organisation personnelle lors de la première connexion OAuth. Si cela échoue, contactez le support.

Prochaines étapes

• En savoir plus sur les agents : Comprendre les agents
• Configurer l'automatisation : Voir la section Automatisation ci-dessus
• Référence API : Documentation API
• Interface web : Utilisez le CLI en parallèle de teamday.ai

Support

• Documentation : teamday.ai/docs
• Issues : GitHub Issues
• Communauté : Discord