Une fois votre application fonctionnelle en local, publiez-la dans le registre de l'App Store pour que les autres utilisateurs de Crew puissent l'installer en un clic. Cette page couvre le flux de travail de bout en bout.
Créez un répertoire d'application avec un app.json à la racine. Consultez :
- Créez votre première application — le tour guidé de 5 minutes
- Référence du manifeste — chaque champ
app.json
Vérifiez que le manifeste est valide :
kirocrew doctor # or: curl http://localhost:5476/api/apps/my-app/manifest | python3 -m json.tool
# Build UI if you have one cd my-app/ui && npm install && npm run build && cd .. # Install via REST API curl -X POST http://localhost:5476/api/apps/install \ -H 'Content-Type: application/json' \ -d '{"source": "./my-app"}' # Enable it curl -X POST http://localhost:5476/api/apps/my-app/enable
Ou utilisez l'interface de l'App Store dans le tableau de bord pour installer depuis un chemin local.
Dans Kiro Crew 0.13.0 ou ultérieur, kirocrew app install accepte aussi une URL git, ce qui vous permet de tester une application directement à partir de son dépôt :
kirocrew app install https://github.com/example/my-app.git --ref main --subdirectory my-app
La commande clone le dépôt avec votre propre connexion git, puis installe le dossier qui contient app.json comme n'importe quel répertoire local. Les mêmes vérifications du manifeste s'appliquent, et l'application démarre désactivée. Consultez kirocrew app install pour les indicateurs et pour la mise à jour ultérieure.
- Ouvrez le tableau de bord Crew (
kirocrew token→ ouvrez l'URL) - Vérifiez App Store → Installed — votre application devrait apparaître
- Si elle a une interface utilisateur, cliquez sur l'entrée dans la barre latérale et vérifiez que la page se charge
- Si elle a des agents, testez-les depuis le chat : demandez à l'agent de faire quelque chose
- Si elle a des tâches cron, vérifiez la page Schedule — votre tâche cron devrait y être listée
# Check the app is registered curl http://localhost:5476/api/apps | python3 -m json.tool # Check the manifest is valid curl http://localhost:5476/api/apps/my-app/manifest | python3 -m json.tool # Tail gateway logs kirocrew logs -f
# Edit code vim ui/src/App.tsx # Rebuild UI cd ui && npm run build && cd .. # Update the installed app curl -X POST http://localhost:5476/api/apps/my-app/update
Pour une itération plus rapide, utilisez kirocrew app dev my-app — la passerelle recharge l'application à chaud à chaque changement de fichier.
Avant de soumettre au registre :
-
app.jsonpasse la validation -
nameest en kebab-case, unique globalement, descriptif -
versionsuit le semver (1.0.0) -
displayNameetdescriptionsont clairs et concis -
authorest défini -
tagsfacilitent la découverte -
permissionssont minimales — ne déclarez que ce que vous utilisez réellement - Le paquet UI est construit et committé (
ui/dist/index.mjs) - Les fichiers JSON des agents sont valides
- Les fichiers
SKILL.mddes Skills ont un frontmatter approprié -
README.mdexplique ce que fait l'application et comment l'utiliser - Si vous avez
setup.onInstall, testez-le sur une machine propre
Lorsque Crew installe ou met à jour votre application, il copie l'arborescence source dans ~/.kiro/crew/apps/{name}/ avec deux mesures de protection :
- Les liens symboliques ne sont jamais suivis. Un lien symbolique dont la cible se résout à l'intérieur de l'arborescence source de votre application est conservé comme lien symbolique; un lien symbolique se résolvant à l'extérieur est omis entièrement. Les artefacts d'exécution committés doivent être de vrais fichiers (ou des liens relatifs internes à l'arborescence).
- Les répertoires d'entrée de build et de VCS sont exclus :
node_modules,.git,__pycache__,.venv(à toute profondeur) sont retirés de la copie installée.
Servez votre interface utilisateur depuis le paquet committé ui/dist/. Rien dont votre application a besoin à l'exécution ne doit se trouver sous ces noms exclus.
Votre application devrait vivre dans son propre dépôt git (ou un sous-répertoire d'un dépôt existant) :
MyAppRepo/ ├── app.json ├── agents/ ├── skills/ ├── ui/ │ ├── src/ │ └── dist/index.mjs ← committed build artifact ├── scripts/ │ └── install.sh ← optional; invoked by setup.onInstall in app.json └── README.md
Icône de l'application :
- Format : PNG avec transparence
- Taille : minimum 256×256, rapport d'aspect carré
- Emplacement : committez dans votre dépôt (p. ex.
assets/icon/logo.png)
Captures d'écran :
- Format : PNG ou JPG
- Recommandé : 1200 px de large, rapport 16:9
- Emplacement : committez dans votre dépôt
- Maximum 5 captures d'écran par application
Images héros (16:9 recommandé, 1200×675) :
heroImage— thème clairheroImageDark— thème sombreheroImageDetail/heroImageDetailDark— bannière de la page de détail (25:6, 1200×288)
L'App Store diffuse les icônes et les images via un proxy de blob git — aucun CDN ni hébergement externe n'est nécessaire.
Le registre de l'App Store est src/kiro_crew/apps/app-registry.json dans le dépôt Crew. Ajouter votre application signifie ouvrir une pull request.
[ { "name": "my-app", "gitUrl": "https://github.com/yourname/my-app", "branch": "main" } ]
Si votre application se trouve dans un sous-répertoire d'un dépôt plus grand :
{ "name": "my-app", "gitUrl": "https://github.com/yourname/monorepo", "branch": "main", "subdirectory": "apps/my-app" }
| Champ | Requis | Description |
|---|---|---|
name | Oui | Doit correspondre au name dans votre app.json |
gitUrl | Oui | Toute URL clonable par git (https://…, git@…) |
branch | Oui | Branche à cloner (habituellement main) |
subdirectory | Non | Chemin dans le dépôt si app.json n'est pas à la racine |
resources | Non | "gateway" (par défaut) ou "app" — voir ci-dessous |
lifecycle | Non | "gateway" (par défaut), "app", ou "locked" |
detectInstalled | Non | Commande shell qui se termine avec le code 0 si l'application est déjà installée (pour les applications autogérées) |
Le champ repo est le raccourci historique pour gitUrl et est toujours accepté.
L'entrée du registre est intentionnellement minimale — votre app.json est la source unique de vérité. Toutes les informations d'affichage (description, captures d'écran, points forts, tags, version) sont récupérées depuis votre dépôt. Vous n'avez pas à synchroniser les métadonnées entre votre dépôt et le registre.
cd /path/to/Crew git checkout -b add-my-app # Edit src/kiro_crew/apps/app-registry.json git add src/kiro_crew/apps/app-registry.json git commit -m "feat(apps): add my-app to registry" git push origin add-my-app # Open a PR titled "Add my-app to App Store registry"
app.jsonest valide et complet- Les permissions sont raisonnables (pas d'accès inutile)
- Aucune traversée de chemin dans les chemins de ressources
- Le script d'installation (le cas échéant) est sécuritaire
- L'application apporte de la valeur aux utilisateurs de Crew
Les équipes peuvent héberger leurs propres registres d'applications sans nécessiter de révision par l'équipe Crew. Les utilisateurs y adhèrent en ajoutant des registres externes à leur configuration :
{ "registries": [ {"name": "team-a", "repo": "TeamAKirocrewAppRegistry", "branch": "main"} ] }
Le fichier d'entrée de registre à la racine du dépôt de registre reflète le format ci-dessus (un tableau d'entrées d'applications).
Modèle de confiance : l'utilisateur y adhère explicitement en ajoutant le registre à sa configuration. Le dépôt doit être accessible via git.
API de gestion (/api/apps/registries) :
| Méthode | Objectif |
|---|---|
GET /api/apps/registries | Retourne la liste actuelle des registres depuis la configuration |
PUT /api/apps/registries | Valide et remplace le tableau des registres |
Validation des entrées : les noms de dépôt et de branche sont validés par rapport à des motifs regex stricts pour rejeter la traversée de chemin. Le dépôt Crew lui-même est bloqué.
Après la fusion de votre PR :
- Les utilisateurs ouvrent l'App Store → l'onglet Browse, trouvent votre application
- Cliquent sur Install — Crew clone votre dépôt (superficiel, branche spécifique)
- Exécute
setup.onInstallsi défini - Copie l'application dans
~/.kiro/crew/apps/my-app/ - Enregistre les agents, Skills, tâches cron via des liens symboliques
- L'application apparaît dans le tableau de bord
Pousser une mise à jour :
- Mettez à jour le code de votre application
- Incrémentez
versiondansapp.json - Committez et poussez
Les utilisateurs peuvent mettre à jour via l'interface de l'App Store (bouton de rafraîchissement) ou l'API REST :
curl -X POST http://localhost:5476/api/apps/my-app/update
Ceci re-clone, ré-exécute onUpdate, et ré-enregistre les ressources.
Certaines applications gèrent leur propre installation et l'enregistrement de leurs ressources. Elles s'enregistrent auprès de Crew pour la visibilité dans l'App Store, mais gèrent leur propre cycle de vie.
{ "name": "my-desktop-app", "repo": "MyDesktopApp", "branch": "mainline", "resources": "app", "lifecycle": "app", "detectInstalled": "test -d ~/Applications/MyDesktopApp.app" }
Applications autogérées :
- S'affichent dans l'App Store comme « Self-managed »
- Gèrent elles-mêmes l'installation, la mise à jour et la désinstallation
- S'enregistrent via
POST /api/apps/registerà l'exécution - Crew ne fait que suivre les métadonnées
Les applications déclarent minKiroCrewVersion dans app.json. L'installation et la mise à jour vérifient cette valeur — si la version actuelle est trop ancienne, l'opération est rejetée avec un message d'erreur clair indiquant à l'utilisateur de mettre à jour Crew d'abord.
Les applications peuvent utiliser npm (pour TypeScript/React) ou pip (pour Python) comme système de build. L'App Store clone le dépôt et exécute la commande de build appropriée.
- Crew crée un espace de travail à
~/.kiro/crew/app-sources/{name}/ - Clone le paquet à la branche spécifiée (superficiel)
- Exécute
npm install && npm run build(JS/TS) oupip install .(Python) setup.onInstalls'exécute après le build (pour des étapes post-build commeelectron-builder)
Puisque l'étape de build standard gère la résolution des dépendances et la compilation, votre script onInstall ne devrait faire que de l'empaquetage post-build :
#!/usr/bin/env bash set -euo pipefail [ -d "node_modules" ] || exit 1 # sanity check — build should have run npx electron-builder --mac --dir cp -R release/mac-arm64/MyApp.app ~/Applications/MyApp.app
- Utilisez le semver :
major.minor.patch - Incrémentez
patchpour les corrections de bogues - Incrémentez
minorpour les nouvelles fonctionnalités - Incrémentez
majorpour les changements avec rupture de compatibilité (schéma de configuration d'agent, interface d'outil MCP)
L'entrée du registre n'a pas de champ de version — incrémentez simplement app.json et poussez. L'App Store récupère le dernier app.json depuis votre dépôt (mis en cache 24 h, ou immédiatement lors d'un rafraîchissement par l'utilisateur).
| Étape | Commande / action |
|---|---|
| Créer | Créer un répertoire d'application avec app.json |
| Construire l'UI | cd ui && npm run build |
| Installer localement | POST /api/apps/install ou l'interface de l'App Store |
| Activer | POST /api/apps/{name}/enable |
| Tester | Ouvrir le tableau de bord, vérifier l'UI + les agents + les tâches cron |
| Soumettre | Ajouter à app-registry.json, ouvrir une PR |
| Installation utilisateur | App Store → Browse → Install |
| Mettre à jour | Incrémenter la version, pousser, les utilisateurs réinstallent |
- Questions : ouvrez une discussion sur le dépôt GitHub de Crew
- Bogues : ouvrez un problème GitHub
- Demandes de fonctionnalités : idem, étiquette
app-store
Publication et lignes directrices