aggrega registry
Gérer les registries et leur politique de confiance des signatures
Synopsis
aggrega registryDescription
Manage the OCI registries Aggrega publishes to and resolves from, together withthe signature trust policy for each.
A registry entry records where to reach the registry and what to require of thesignatures on artifacts it serves — which identities are trusted, and whether asignature is required at all. That policy is what "aggrega pull" enforces whenit verifies an artifact and what "aggrega push" honours when it decides whetherto sign.
"aggrega registry add" can fetch a registry's own advertised trust policy ratherthan having you write it out. "aggrega registry update" builds the localsearchable index that "aggrega search" and "aggrega plugin add" read.
A registry entry is written to the global config shared across every workspaceon this machine, because a registry and the identities you trust on it areusually the same wherever you work. That makes adding or removing one amachine-wide change: every project on this machine resolves through the entryyou just wrote or dropped. Pass --workspace to write it to this project's configfile instead. Building the searchable index is the exception — that lands inthis workspace's own artifact cache and reaches no other project.Sous-commandes
| Commande | Description |
|---|---|
aggrega registry add | Enregistrer un registry et sa politique de confiance des signatures |
aggrega registry list | Lister les registries configurés et leur posture de confiance |
aggrega registry remove | Supprimer un registry et sa politique de confiance d’un fichier de configuration |
aggrega registry update | Construire l’index local consultable des registries configurés |
Description de aggrega registry add
Register a registry host and its signature trust policy.
The entry is keyed under the host exactly as written, and every lookup of it ismade in one spelling: a lowercase host name containing a dot, localhost, a singlename followed by a port (registry:5000), an IPv4 address, or an IPv6 address inbrackets, each with an optional :port. A reference may be given instead — itsscheme, path and credentials are dropped and the entry is keyed under the host itnames — but a host written in capitals, with the default HTTPS port, or as asingle name with no port is refused, naming the spelling to write where there isone.
The entry is written to the global config shared across every workspace, since aregistry and the identities you trust on it are usually the same wherever youwork. Pass --workspace to write it to this project's config file instead; the twoflags are mutually exclusive.
By default the registry's advertised trust policy is fetched once from theregistry's own origin (https://<host>/.well-known/aggrega-trust) and pinnedlocally — trust-on-first-use. Verification at pull time always runs against thepinned local policy, never a live re-fetch. Pass --fetch-trust=false to skip thefetch and pin only what the flags supply.
A trust policy can also be set by hand: keyless (one or more --identity entries,each an "identity=issuer" pair) or keyed (--key pointing at a pinned public-keyPEM). Manual --identity / --key flags OVERRIDE the fetched set — when either issupplied, the fetch is skipped and the policy is built from the flags alone.Pass --trusted-root to pin a Sigstore trust-root bundle for air-gapped keylessverification. Adding the official hub host with no policy flags pins the built-inofficial baseline.
When the registry advertises no trust policy (a 404 or an unreachable endpoint),the add does not fail: it writes the policy from the flags (or an empty policy)and prints a notice suggesting manual --identity / --key pinning. The officialhub writes its built-in baseline instead, and the notice says the baseline waspinned.
When the workspace is offline the advertised policy cannot be fetched, so theregistry is never asked. Adding a registry other than the official hub is thenrefused unless --identity or --key supplies the policy, rather than writing anentry that trusts nothing: register it once while online, or pin it by hand.Adding the official hub offline pins its built-in baseline, with a notice sayingso, and a manual policy registers offline exactly as it does online.
Existing settings in the target config file are preserved.Flags de aggrega registry add
| Option | Par défaut | Description |
|---|---|---|
--advisory | false | Rétrograder les échecs de vérification pour ce registry en avertissements au lieu de s’arrêter |
--fetch-trust | true | Récupérer et épingler la politique de confiance annoncée par le registry lors de la première utilisation. Utilisez —fetch-trust=false pour l’ignorer ; des —identity/—key manuels ignorent aussi la récupération. |
--global | false | Écrire l’entrée dans la configuration globale partagée par tous les workspaces. Un registry va ici par défaut. |
--identity | [] | Identité keyless de confiance sous la forme identity=issuer, par exemple dev@example.com=https://accounts.google.com (répétable ; ensemble OU). Remplace la politique de confiance récupérée. |
--key | — | Chemin vers un PEM de clé publique épinglée compatible cosign pour la vérification keyed. Remplace la politique de confiance récupérée. |
--name | — | Alias convivial facultatif pour ce registry. L’hôte reste l’identité ; l’alias se résout vers lui partout où un registry est nommé (p. ex. —registry). Doit être unique parmi les registries. |
--require-signatures | false | Exiger une signature sur chaque artefact récupéré depuis (et poussé vers) ce registry |
--trusted-root | — | Chemin vers un bundle de racine de confiance Sigstore épinglé pour la vérification keyless en environnement isolé (air-gapped) |
--workspace | false | Écrit l’entrée dans la configuration du workspace de ce projet au lieu de la configuration globale. |
Description de aggrega registry list
List every registry configured in the effective merged config, one per line,with its friendly alias (if any), a short trust-posture summary, and a marker onthe default registry.
This reads the resolved configuration and never contacts a registry. Registriesare listed in ascending host order.
With -o json the same set is emitted as one structured document per registry:its host, its alias, whether it is the default, its trust posture as discretefields rather than the table's rendered sentence, and whether a credential forthat host is present in the shared credential store. The credential state reportspresence only — a credential is never read out, measured, or shown in any form,and whether the registry would accept it is not asked, since that would take anetwork round trip. Reading it consults the local credential store, which honorsa configured credential helper. The order is the same ascending host order thetable uses.Flags de aggrega registry list
| Option | Par défaut | Description |
|---|---|---|
--output, -o | table | Format de sortie : table|json. |
Description de aggrega registry remove
Remove a registry's trust-policy entry from a config file, addressed by its hostor its friendly alias.
By default the entry is removed from the global config shared across everyworkspace; pass --workspace to remove it from this project's workspace configinstead. Setting both --global and --workspace is a usage error.
The default_registry pointer is left untouched — removing a registry's trustpolicy reverts that host to default trust; it does not change which registry isthe default. Where default_registry names the removed entry by its alias, thatalias names nothing afterwards, and the configuration is refused untildefault_registry is written as a host or as another entry's name.Flags de aggrega registry remove
| Option | Par défaut | Description |
|---|---|---|
--global | false | Supprimer l’entrée de la configuration globale partagée par tous les workspaces. |
--workspace | false | Supprimer l’entrée de la configuration du workspace de ce projet au lieu de la configuration globale. |
Description de aggrega registry update
Walk each configured registry's repositories, read the latest published versionof each, and write a deterministic local searchable index to the artifact cache.
With no argument, every configured registry is indexed. With a single registryargument (a host or a friendly alias), only that registry is indexed.
This is the one registry command that reaches the network. The index it writeslands in this workspace's own artifact cache, so refreshing it changes nothinganother project on this machine resolves through. Credentials are read from asupplied or ambient source and never asked for: a registry that needs one you donot have fails with a message naming what it wanted.
For each repository the highest strict-SemVer version is selected (pre-releaseversions are skipped) and its catalog facets — kind, description, category,labels, and, for plugins, socket type and capabilities — are recorded from thepublished manifest. A repository with no conforming version is skipped; arepository that cannot be read is skipped with a note, so one unreadablerepository does not abandon the whole index.
A registry that asks the walk to slow down — a 429 answer, or a 503 that sayshow long to wait (Retry-After) — is left alone for as long as it asks, or tenseconds where it does not say, and the walk reads fewer of its repositories atonce until it answers again, then returns to its usual pace; on a terminal thewait is shown beside that registry's row. A registry that answers nothing but"slow down" for five minutes is not indexed: it keeps the index it had beforethe run, and the command names it, its last answer and how long it waited.
A read the registry fails or drops in passing — a 5xx answer, a connectionreset or timed out, an answer cut short — is asked again a few times, with agrowing wait between attempts. A repository with a read stillfailing after that is not recorded from this run: it keeps the record the indexalready holds for it, where that record was judged under the trust policy now inforce, and is otherwise left out of the index; either way it is named as arepository that could not be read, as the walk goes and again in the closingsummary under its registry's row, with the kind of the read's last failure — thestatus the registry answered, a timeout, a reset, an answer cut short — and theread that failed. So a version is never recorded unsigned,undated or without its deprecation marker because a read failed, with or without--upgrade. Each registry's row in the closing summary also says how many readswere asked again, whether or not they then succeeded — a read sent again afterthe registry asked the walk to slow down among them — and says zero when nonewas.
Every signature a registry's walk verifies against the public Sigstore trust rootis verified against the same copy of that root, fetched once for the walk ratherthan once per signature; a registry whose trust policy pins a trust root of itsown is verified against that file.
A registry whose repository listing repeats itself — naming a repository it hasalready named, or answering two pages in a row with no repository while stillpointing to a next page — is not followed round again. That registry is reportedas not indexed, with a message naming it and saying its repository listingrepeated itself; the other registries are still indexed, and the command exitsnon-zero.
A registry that is not indexed keeps the index it had before the run, unchanged:nothing is written for a registry whose walk failed, whose listing repeateditself, or that was being walked when the command was interrupted. Registriesindexed earlier in the same run keep what this run wrote for them. A registry'snew index is written aside and put in place whole, so a command stopped whilewriting one leaves that registry with a complete index — the one it had beforethe run, or the new one — or with none, never with a partial one.
Every strict-SemVer version a recorded repository publishes is listed too, eachwith the manifest digest its tag resolves to — the address of the exact bytespublished under that version. Where the registry's trust policy pins a public keyor trusted identities, and verification is not switched off, each version's ownsignatures are verified against that policy and the signer is recorded when oneverifies; a version with no signature, or none that verifies, is recorded with nosigner. Where several verify, the signer recorded is the one the transparency logrecorded earliest, whatever order the registry lists them in, so signing a versionagain never changes its recorded signer.
Each version's publication date is recorded too, with its source. Where one of theversion's keyless signatures verified, the date is the time the transparency logrecorded that earliest signature, as the verified log entry attests it (source'transparency-log') — so signing a version again never moves its date. Otherwiseit is the date the publication itself stated beside what it published (source'publisher'), the earliest where several are stated: the publishing machine's ownclock, which nothing attests, read from any registry whatever its trust policy.A version with neither — published without stating a date, and not signedkeyless in a way this policy verifies — is recorded with no date.
Only manifests, signature attachments and publication-date attachments are read:no entity's content is fetched. 'aggrega search -o json' reports these under eachrecord's 'published' field.
The per-repository records are byte-identical across two runs against the sameregistry state; the freshness timestamp is written to a sibling file so it neverdisturbs the records.
A refresh reads again only what changed, and finds every change a full re-readwould. For each repository it revalidates the tag listing with a conditionalrequest, resolves every version's tag to its manifest digest, and revalidates everyversion's attachments — its signatures, publication-date statements and deprecationmarkers — with one conditional request, plus one for the signatures of adeprecation marker it judged before. A version whose digest or attachments changedis read again in full, and its signatures and markers are verified again exactly asa full re-read verifies them; everything else is kept as recorded. A change to thisregistry's trust policy reads every version again under the policy now in force, andso does a repository whose entry in the index records none of these checks. Anunchanged registry therefore costs one conditional request per repository and twosmall requests per version (three where a deprecation marker was judged), withnothing downloaded. A version is read again on the next refresh where it carries adeprecation marker that was not honored, or where this run got no way torevalidate its attachments — which, on a registry that offers none, is everyversion.
Several repositories are read at a time. Everything the command records and printscomes out in repository order, so the index and the output are the same as readingone repository at a time would produce.
While it walks, a terminal shows the walk's progress on standard error, the waybuild and pull show theirs: a row naming each registry, a spinner while thatregistry's repository listing is read, then how many of its repositories the walkhas finished out of how many it lists, counted in repository order, and a bar forthe whole walk below the rows. On a terminal that cannot redraw in place, or with--plain, each registry gets one plain line instead, written when its walk ends,with the count it ended on and the time it took. When standard error is not aterminal, no progress is shown. The progress changes nothing the command prints onstandard output.
Use --upgrade to read every repository in full, comparing nothing with the indexalready written — to rebuild an index from the registry alone. It finds no change arefresh without it would miss.
Each published version's deprecation markers are read as the walk goes, and the oneswhose own signature verifies are recorded into the index. Every marker read isreported, whether or not it was recorded — a version kept as recorded is not read, soits marker is not reported again — and each registry reports how many markers itsindex now records, including when that number is zero. Where signatureverification is disabled for a registry, the walk reports that its markers were notexamined rather than a count, so a registry that published nothing is never confusedwith one this run had no basis to judge.Flags de aggrega registry update
| Option | Par défaut | Description |
|---|---|---|
--upgrade | false | Lit chaque dépôt en entier, sans rien comparer à l’index déjà écrit (un rafraîchissement sans cette option relit déjà tout ce qui a changé) |
Ce que registry update signale au sujet des marqueurs de dépréciation
Pendant qu’il parcourt un registry, aggrega registry update lit les marqueurs de dépréciation de chaque version publiée et enregistre dans l’index local ceux qu’il peut authentifier. Il signale le résultat de cette analyse dans tous les cas, de sorte qu’un registry qui n’a publié aucun marqueur se distingue d’une exécution qui n’en a pas cherché.
Chaque marqueur que lit le parcours produit une ligne nommant le dépôt, la version et la gravité enregistrée par l’éditeur — warning, error ou retracted —, en indiquant si le marqueur a été enregistré. Une version dont les pièces jointes n’ont pas changé depuis le dernier rafraîchissement est conservée telle qu’enregistrée au lieu d’être relue, de sorte que son marqueur n’est pas signalé à nouveau ; le décompte ci-dessous l’inclut néanmoins. Un marqueur n’est enregistré que lorsque sa propre signature se vérifie auprès des signataires que reconnaît la politique de confiance du registre. Un marqueur présent mais qui ne se décode pas, ou présent mais non reconnu, est signalé comme tel et laissé hors de l’index plutôt qu’enregistré sur la foi d’éléments qui n’ont pas pu être authentifiés — de même qu’un marqueur dont le registre répond qu’il ne le détient pas. Un marqueur dont la lecture a échoué est un cas différent : voir Une lecture qui échoue.
Chaque registry signale ensuite combien de marqueurs son index enregistre désormais, y compris lorsque ce nombre est zéro. Lorsque la vérification des signatures est désactivée — globalement, ou pour ce seul registry —, le parcours signale à la place que les marqueurs n’ont pas été examinés pour lui. Ce sont deux faits différents : le premier dit que le registry n’a rien publié sur quoi ce workspace puisse agir, le second dit que cette exécution n’avait aucune base de confiance pour juger un marqueur. Un registry dont les marqueurs n’ont pas été examinés n’apporte aucun retrait à la sélection des versions, de sorte qu’un auteur qui a attaché un marqueur et voit cette ligne sait pourquoi il n’a aucun effet.
La date de publication enregistrée pour chaque version
L’heure de création d’un manifest publié est figée, de sorte que son digest ne dépend que de ce qui est publié et jamais du moment. La date de publication d’une version est donc lue à côté du manifest, et aggrega registry update l’enregistre pour chaque version avec la source dont elle provient :
transparency-log— lorsque la signature de la version est keyless et se vérifie selon la politique de confiance du registry, le moment où le journal de transparence a enregistré cette signature, attesté par la promesse signée du journal. Lorsque plusieurs signatures de la version se vérifient, c’est le plus ancien de leurs moments, et le signataire enregistré pour la version est celui de cette même signature — quel que soit l’ordre dans lequel le registry liste les signatures —, de sorte qu’une version signée à nouveau conserve sa date et son signataire. Pour une version signée lors de sa publication, c’est sa publication ; pour une version signée pour la première fois ensuite avecaggrega sign, c’est le moment de sa signature. Cette source l’emporte partout où elle existe.publisher— sinon, le moment que la publication a déclaré à côté de ce qu’elle a publié : une petite pièce jointe published-at queaggrega pushetaggrega push-artifactécrivent avec l’horloge de la machine qui publie, que rien n’atteste. Elle est lue depuis n’importe quel registry, quelle que soit sa politique de confiance, car c’est la déclaration de l’éditeur et non une décision de confiance. Lorsque plusieurs sont attachées, la plus ancienne est retenue.
Une version sans l’une ni l’autre n’enregistre aucune date. C’est une publication qui n’en a déclaré aucune, et dont la signature n’est pas une signature keyless que cette politique vérifie — par exemple une publication keyless lue sous une politique qui ne fait confiance à aucune identité keyless, puisqu’une publication keyless ne déclare aucune date propre. aggrega search -o json indique la date sous chaque version dans published.
Ce qu’un rafraîchissement relit
Un rafraîchissement compare ce que le registre sert maintenant à ce que l’index a enregistré, et relit tout ce qui a changé — la même réponse que donne une relecture complète. Pour chaque dépôt, il :
- revalide la liste des tags, de sorte qu’une version publiée ou supprimée depuis est prise en compte ;
- résout le tag de chaque version vers le manifest qu’il nomme, de sorte qu’une version plus ancienne republiée sous son tag existant est relue ;
- revalide les pièces jointes de chaque version — ses signatures, ses déclarations de date de publication et ses marqueurs de dépréciation — de sorte qu’une signature, une date ou un marqueur attaché depuis à une version est lu et vérifié, et fait de même pour les signatures d’un marqueur de dépréciation qu’il a déjà jugé ;
- compare la politique de confiance du registre à celle sous laquelle l’index a été construit, de sorte qu’une modification de la politique fait relire chaque version sous la nouvelle.
Un marqueur de dépréciation, une signature et une date de publication sont chacun attachés à une version publiée comme un objet distinct qui pointe vers elle — c’est ce qui permet à un éditeur de déprécier ou de signer une version sans la republier —, de sorte qu’aucun d’eux n’ajoute de tag ni ne modifie le manifest propre de la version. Ils modifient les pièces jointes de la version, et c’est ce que revalide la troisième vérification. L’exclusion de versions et aggrega inspect lisent tous deux cet index, de sorte qu’une version retirée depuis le dernier rafraîchissement est exclue de la sélection, et affichée, une fois que le rafraîchissement suivant s’est exécuté.
Chaque vérification est une petite requête — la résolution de l’empreinte d’un manifest, ou une requête conditionnelle à laquelle le registre répond qu’il n’y a pas de changement sans rien envoyer — de sorte que le rafraîchissement d’un registre inchangé ne télécharge rien. Une version qui porte un marqueur de dépréciation non reconnu, ou dont cette exécution n’a eu aucun moyen de revalider les pièces jointes, est relue au rafraîchissement suivant. Un registre qui ne peut pas dire si les pièces jointes d’une version ont changé fait relire chaque version à chaque rafraîchissement : la réponse est la même, et le coût d’une relecture complète aussi.
--upgrade lit chaque dépôt en entier, sans rien comparer à l’index déjà écrit. Utilisez-le pour reconstruire un index à partir du seul registre ; il ne prend en compte rien de ce qu’un rafraîchissement manquerait.
Un registre qui demande de ralentir
Le hub officiel, hub.aggrega.ai, limite le nombre de requêtes pouvant provenir d’une même adresse sur une courte période, si bien que les machines qui partagent une adresse partagent ce quota, et tout registre peut limiter ses clients de la même manière. Un registre ayant dépassé sa limite répond 429 Too Many Requests, ou 503 Service Unavailable avec un en-tête Retry-After indiquant combien de temps attendre. Chaque requête que la ligne de commande adresse à un registre, quelle que soit la commande, réagit à cette réponse de la même manière : elle attend aussi longtemps que le registre l’a demandé, ou dix secondes lorsque la réponse ne le précise pas, plus jusqu’à une seconde supplémentaire tirée au hasard, puis redemande, sans nombre fixe de tentatives. Chaque requête vers ce registre attend avec elle, pas seulement celle qui a été refusée, et moins de requêtes lui sont envoyées à la fois — moitié moins chaque fois qu’il le demande, jusqu’à une seule —, ce nombre remontant d’une unité après chaque série de requêtes qu’il sert sans échec, jusqu’au nombre habituel de la commande. L’attente est affichée dans les mêmes conditions que le reste de la progression de la commande, sous forme d’une ligne telle que hub.aggrega.ai asked to slow down; waiting 11 s : aggrega build, aggrega pull et aggrega registry update l’affichent à côté de l’étape en cours, les autres commandes qui affichent ce qu’elles attendent l’affichent comme une étape à part entière — sauf aggrega sign --jobs signant plusieurs références à la fois, qui affiche ces attentes comme une seule étape — et rien n’est affiché lorsque la sortie d’erreur standard n’est pas un terminal, à moins que le --progress de la commande ne le demande. Un registre qui ne répond rien d’autre que « ralentissez » pendant cinq minutes est refusé avec E0378, en nommant le registre, sa dernière réponse et depuis combien de temps il ne répondait rien d’autre ; les cinq minutes sont fixes, et aucun paramètre ne les modifie. aggrega registry update nomme alors ce registre sous Not indexed: dans son récapitulatif final, et le registre conserve l’index qu’il avait avant l’exécution.
Une lecture qui échoue
Un parcours lit de nombreux petits objets dans un registre, et certaines lectures échouent en passant : le registre répond qu’il a échoué ou qu’il est indisponible (un statut 5xx, hormis un 503 qui indique combien de temps attendre) ou que la requête a expiré (un 408), la connexion est réinitialisée ou expire, ou une réponse s’interrompt avant d’être complète. Chacune de ces lectures est redemandée quelques fois, avec une attente croissante entre les tentatives. Un registre qui demande au parcours de ralentir ne fait pas échouer une lecture : la lecture attend et est redemandée comme le décrit Un registre qui demande de ralentir, et un registre qui continue de le demander pendant cinq minutes met fin au parcours de ce registre plutôt qu’à celui d’un seul dépôt.
Une lecture qui échoue encore n’est jamais prise pour une réponse. Une signature qui n’a pas pu être lue n’est pas une version sans signature, et un marqueur de dépréciation qui n’a pas pu être lu n’est pas une version qui n’a jamais été retirée, de sorte que le parcours n’enregistre rien sur ce dépôt lors de cette exécution. Le dépôt conserve l’enregistrement que l’index détient déjà pour lui, lorsque cet enregistrement a été jugé sous la politique de confiance du registre actuellement en vigueur, et est sinon laissé hors de l’index. Dans les deux cas, le parcours nomme le dépôt dans son commentaire en cours, en indiquant lequel des deux cas s’est produit et quelle lecture a échoué, et le nomme à nouveau dans son résumé final, sur une ligne à part sous la ligne de son registre, parmi les dépôts qui n’ont pas pu être lus :
Indexed 1 registry. registry.example.com: 41 entities, 1 repository could not be read, 4 reads retried component/core/web: the registry answered 503 Service Unavailable: …La ligne du registre indique aussi combien de lectures ont été redemandées, chaque lecture étant comptée une seule fois quel que soit le nombre de tentatives qu’elle a nécessitées et qu’elle ait ensuite réussi ou non, et indique 0 reads retried lorsqu’aucune ne l’a été. Un parcours dont toutes les lectures ont fini par réussir n’affiche aucun dépôt sur sa ligne, de sorte que c’est ce décompte qui indique à quel point il a failli en laisser un de côté.
Chacune de ces lignes commence par la nature du dernier échec de la lecture — le statut par lequel le registre a répondu, une lecture qui a expiré, une connexion réinitialisée ou une réponse tronquée — suivie de l’échec lui-même, qui indique de quelle lecture il s’agissait. Un échec qui n’est d’aucune de ces natures, comme une racine de confiance qui n’a pas pu être obtenue pour y vérifier une signature, est donné par l’échec seul. La méthode aggrega/registryUpdate d’aggrega serve répond avec les mêmes dépôts sous skipped de chaque hôte, chacun avec le même reason, et avec le nombre de lectures redemandées sous readsRetried. Il en va de même pour un rafraîchissement et pour --upgrade, et le parcours suivant part de ce que l’index détient alors, comme pour tout dépôt.
La clé publique qu’épingle une politique keyed
Une politique de confiance keyed épingle la clé publique du registry inline, comme public_key de l’entrée : aggrega registry add --key <file> y copie le contenu du fichier, tout comme l’épinglage d’une politique que le registry annonce avec une clé. La valeur est un bloc PEM de clé publique — le texte allant d’une ligne -----BEGIN PUBLIC KEY-----, ou -----BEGIN RSA PUBLIC KEY-----, jusqu’à la ligne -----END correspondante — et tout texte au-dessus du bloc est ignoré.
Une valeur ne contenant aucune ligne -----BEGIN … PUBLIC KEY----- est refusée au chargement du fichier de configuration, avec le nom du fichier et de l’entrée. registry add effectue la même vérification avant d’écrire, de sorte qu’un fichier --key contenant autre chose — une clé privée, un certificat ou une clé dans un autre encodage — est refusé et le fichier de configuration reste tel qu’il était. Seule cette ligne est vérifiée : on découvre si le bloc se décode en une clé utilisable lorsqu’une signature du registry est vérifiée par rapport à lui.
Hors ligne
aggrega registry update est la seule commande de ce groupe dont tout le travail consiste à parcourir les registries, et en mode hors ligne — la clé de premier niveau offline dans un fichier de configuration, AGGREGA_OFFLINE ou --offline — elle refuse avant de parcourir quoi que ce soit. Le refus indique laquelle des trois sources a défini le mode.
Il n’existe aucune forme partielle de repli, car l’index enregistre ce que chaque registry sert actuellement, et cela ne peut s’apprendre sans en interroger un. Ce qu’un workspace hors ligne peut faire, c’est lire l’index qu’il possède déjà : aggrega search et l’avis de dépréciation de aggrega inspect lisent tous deux l’instantané local et ne nécessitent aucun réseau, de sorte qu’un rafraîchissement est la seule chose que le mode retire. Pour rafraîchir le temps d’une exécution depuis un workspace hors ligne, passez --offline=false.
aggrega registry add accède au réseau une seule fois, pour la politique de confiance qu’annonce le registry, sauf si --fetch-trust=false, --identity ou --key indique de ne pas la récupérer. En mode hors ligne, cette récupération est refusée avant toute connexion, de sorte que le registry n’est jamais interrogé. L’ajout d’un registry autre que le hub officiel est alors refusé — ajouter un registry est le seul moment où sa confiance est épinglée, et une entrée écrite sans la politique ne ferait confiance à rien tandis que chaque pull ultérieur y soumettrait le registry. Le refus porte le code court E0310 et nomme les deux voies possibles : l’enregistrer une fois en ligne, ce que --offline=false permet pour une exécution, ou épingler la politique à la main avec --identity ou --key, ce qui enregistre exactement ce que vous fournissez sans aucune récupération. Le hub officiel est ajouté avec sa baseline intégrée, accompagné d’un avis indiquant que sa politique de confiance n’a pas été demandée au hub parce que le workspace est hors ligne et que la baseline est utilisée à la place, et --fetch-trust=false enregistre l’entrée à partir de ses flags exactement comme en ligne. Le même enregistrement effectué via aggrega serve ou aggrega mcp se comporte de la même manière : le même refus dans les mêmes termes, et sinon la même entrée. A registry is added offline with no trust policy to pin (Un registry est ajouté hors ligne sans politique de confiance à épingler) cite le refus.
list et remove modifient ou lisent la configuration locale et ne sont pas concernées.