Publication et lignes directrices

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.

1. Ouvrez le tableau de bord Crew (kirocrew token → ouvrez l'URL)
2. Vérifiez App Store → Installed — votre application devrait apparaître
3. Si elle a une interface utilisateur, cliquez sur l'entrée dans la barre latérale et vérifiez que la page se charge
4. Si elle a des agents, testez-les depuis le chat : demandez à l'agent de faire quelque chose
5. 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.json passe la validation
• name est en kebab-case, unique globalement, descriptif
• version suit le semver (1.0.0)
• displayName et description sont clairs et concis
• author est défini
• tags facilitent la découverte
• permissions sont 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.md des Skills ont un frontmatter approprié
• README.md explique 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 clair
• heroImageDark — thème sombre
• heroImageDetail / 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"
}

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"

1. app.json est valide et complet
2. Les permissions sont raisonnables (pas d'accès inutile)
3. Aucune traversée de chemin dans les chemins de ressources
4. Le script d'installation (le cas échéant) est sécuritaire
5. 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) :

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 :

1. Les utilisateurs ouvrent l'App Store → l'onglet Browse, trouvent votre application
2. Cliquent sur Install — Crew clone votre dépôt (superficiel, branche spécifique)
3. Exécute setup.onInstall si défini
4. Copie l'application dans ~/.kiro/crew/apps/my-app/
5. Enregistre les agents, Skills, tâches cron via des liens symboliques
6. L'application apparaît dans le tableau de bord

Pousser une mise à jour :

1. Mettez à jour le code de votre application
2. Incrémentez version dans app.json
3. 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 minCrewVersion 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.

1. Crew crée un espace de travail à ~/.kiro/crew/app-sources/{name}/
2. Clone le paquet à la branche spécifiée (superficiel)
3. Exécute npm install && npm run build (JS/TS) ou pip install . (Python)
4. setup.onInstall s'exécute après le build (pour des étapes post-build comme electron-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 patch pour les corrections de bogues
• Incrémentez minor pour les nouvelles fonctionnalités
• Incrémentez major pour 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).

• 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