Applications

L'App Kit est ce qui transforme Crew en plateforme. Une application est un paquet qui contribue toute combinaison d'agents, de skills, de serveurs MCP, de tâches cron, de pages d'interface utilisateur du tableau de bord ou de processus backend à Crew. Les utilisateurs installent des applications à partir de l'App Store intégré; les développeurs publient des applications en ajoutant une entrée au registre d'applications.

Cette section couvre la page d'accueil des applications, ainsi que quatre sous-pages :

• Créer votre première application — obtenez une application en fonctionnement en 5 minutes
• Référence du manifeste — chaque champ dans app.json
• Référence SDK / API — API clients TypeScript et Python
• Publication et directives — du développement à l'inscription à l'App Store

Une application peut contribuer tout sous-ensemble de ce qui suit :

Une application qui ne fournit que des skills est un seul fichier. Une application qui fournit un agent complet + backend + interface utilisateur peut être un projet entier.

À partir de l'App Store dans le tableau de bord :

1. Parcourez ou recherchez une application
2. Cliquez sur Install — Crew clone le dépôt, exécute le script d'installation de l'application et copie les fichiers dans ~/.kiro/crew/apps/{name}/
3. Cliquez sur Enable — l'application enregistre ses ressources (agents, skills, tâches cron, serveurs MCP) et les hooks de cycle de vie se déclenchent
4. L'application apparaît dans la barre latérale du tableau de bord (si elle possède des pages d'interface utilisateur)

Via l'API REST :

curl -X POST http://localhost:5476/api/apps/install \
  -H 'Content-Type: application/json' \
  -d '{"source": "/path/to/my-app"}'

curl -X POST http://localhost:5476/api/apps/my-app/enable

Via le mode développement de la CLI :

kirocrew app dev my-app         # turn on live-reload for local iteration
kirocrew app dev my-app --off   # turn off

Les applications déclarent qui gère leurs ressources et leur cycle de vie :

resources: "gateway" est le mode par défaut et le plus simple — rédigez un app.json, Crew le lit et branche tout automatiquement. resources: "app" est destiné aux applications autogérées (applications de bureau Electron, binaires natifs) qui doivent contrôler leur propre installation et s'enregistrer à l'exécution via POST /api/apps/register.

L'App Store est une liste organisée dans src/kiro_crew/apps/app-registry.json. Ajouter une application signifie ouvrir une pull request sur le dépôt Crew :

[
  {
    "name": "my-app",
    "gitUrl": "https://github.com/yourname/my-app",
    "branch": "main"
  }
]

Une fois fusionnée, les utilisateurs peuvent installer en un seul clic. Consultez Publication et directives pour le processus complet.

Les équipes peuvent héberger leurs propres registres d'applications sans exiger une révision par l'équipe Crew pour chaque application. Les utilisateurs y adhèrent en ajoutant des registres externes à leur configuration :

{
  "registries": [
    {"name": "team-a", "repo": "TeamAKirocrewAppRegistry", "branch": "main"}
  ]
}

Les registres externes sont recherchés après le registre intégré. Modèle de confiance : l'utilisateur y adhère explicitement en ajoutant le registre.

Les applications avec des processus backend sont accessibles via le proxy inverse de la passerelle à /apps/{name}/api/*. La passerelle signe chaque requête transmise par proxy avec X-Crew-Proxy: <timestamp>:<hmac-sha256> — les backends vérifient cela pour authentifier l'appelant comme étant la passerelle elle-même.

Cela évite les problèmes CORS pour les pages d'interface utilisateur du tableau de bord et donne aux applications un moyen stable, authentifié par la passerelle, de communiquer avec leur propre backend sans émettre de jetons.

Activez le mode développement pour une application installée et la passerelle :

• Diffuse les fichiers d'interface utilisateur de l'application avec Cache-Control: no-store
• Surveille le répertoire ui/ de l'application
• Diffuse un événement WebSocket app_reload à chaque modification de fichier
• Le tableau de bord recharge immédiatement l'application

Flux de travail local recommandé :

# 1. Symlink your source tree into Crew's app directory
ln -sfn /path/to/my-app-src/ui ~/.kiro/crew/apps/my-app/ui

# 2. Turn on dev mode
kirocrew app dev my-app

# 3. Edit → save → dashboard hot-reloads

Désactivez-le lorsque vous avez terminé — le mode développement ajoute une surcharge de surveillance des fichiers.

Les applications déclarent ce à quoi elles peuvent accéder dans app.json :

{
  "permissions": {
    "api": ["/api/crons", "/api/status"],
    "events": ["notification", "slots"],
    "mcpTools": ["cron_add", "cron_list"],
    "storage": true,
    "cron": true,
    "network": false
  }
}

Les applications résident dans des dépôts git distincts. Lors de l'installation, Crew clone le dépôt (superficiel, branche spécifique) dans ~/.kiro/crew/app-sources/{name}/, exécute l'étape de construction (npm install && npm run build pour les paquets JS/TS, pip install . pour Python), puis copie l'application dans ~/.kiro/crew/apps/{name}/.

Les liens symboliques ne sont jamais suivis lors de la copie — un lien symbolique vers l'intérieur de la source de l'application est conservé comme lien symbolique; un lien symbolique vers l'extérieur est abandonné. Les répertoires d'entrée de construction et de VCS (node_modules, .git, __pycache__, .venv) sont exclus de la copie installée — validez les artefacts de construction dans ui/dist/ si l'application en a besoin à l'exécution.

Contribue des agents et des skills. Pas d'interface utilisateur, pas de backend. Exemple : un agent de triage de garde.

{
  "name": "oncall-triage",
  "agents": ["agents/triage.json"],
  "skills": ["skills/ticket-analysis"]
}

Agents + skills + backend + page d'interface utilisateur du tableau de bord. Exemple : un tableau de bord de surveillance.

{
  "name": "service-monitor",
  "agents": ["agents/monitor.json"],
  "backend": { "entryPoint": "backend/app.py" },
  "ui": {
    "entry": "dist/index.mjs",
    "pages": [{ "route": "/apps/service-monitor", "label": "Monitor", "icon": "Activity" }]
  }
}

Application externe (Electron, outil CLI, binaire natif) qui s'enregistre auprès de Crew à l'exécution. Exemple : l'animal de bureau Mochi.

{
  "name": "mochi",
  "resources": "app",
  "lifecycle": "app",
  "platform": { "os": ["macos"], "installMode": "client" }
}

L'application appelle POST /api/apps/register au démarrage et gère ses propres ressources.

Les applications déclarent minCrewVersion dans app.json. L'installation et la mise à jour vérifient cela — si la version actuelle est trop ancienne, l'opération est rejetée avec un message d'erreur clair.