aggrega registry
Gerenciar registries e sua política de confiança de assinaturas
Sinopse
aggrega registryDescrição
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.Subcomandos
| Comando | Descrição |
|---|---|
aggrega registry add | Registrar um registry e sua política de confiança de assinaturas |
aggrega registry list | Listar os registries configurados e sua postura de confiança |
aggrega registry remove | Remover um registry e sua política de confiança de um arquivo de configuração |
aggrega registry update | Construir o índice local pesquisável dos registries configurados |
Descrição 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
| Flag | Padrão | Descrição |
|---|---|---|
--advisory | false | Rebaixar falhas de verificação deste registry para avisos em vez de interromper |
--fetch-trust | true | Buscar e fixar a política de confiança anunciada pelo registry no primeiro uso. Use —fetch-trust=false para pular; —identity/—key manuais também pulam a busca. |
--global | false | Gravar a entrada na configuração global compartilhada por todos os workspaces. Um registry vai para cá por padrão. |
--identity | [] | Identidade keyless confiável como identity=issuer, por exemplo dev@example.com=https://accounts.google.com (repetível; conjunto OR). Substitui a política de confiança buscada. |
--key | — | Caminho para um PEM de chave pública fixada compatível com cosign para verificação keyed. Substitui a política de confiança buscada. |
--name | — | Alias amigável opcional para este registry. O host continua sendo a identidade; o alias é resolvido para ele onde quer que um registry seja nomeado (por exemplo, —registry). Deve ser único entre os registries. |
--require-signatures | false | Exigir uma assinatura em cada artefato baixado deste (e enviado para este) registry |
--trusted-root | — | Caminho para um bundle de raiz de confiança Sigstore fixado para verificação keyless em ambientes isolados (air-gapped) |
--workspace | false | Grava a entrada na configuração do workspace deste projeto em vez da configuração global. |
Descrição 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
| Flag | Padrão | Descrição |
|---|---|---|
--output, -o | table | Formato de saída: table|json. |
Descrição 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
| Flag | Padrão | Descrição |
|---|---|---|
--global | false | Remover a entrada da configuração global compartilhada por todos os workspaces. |
--workspace | false | Remover a entrada da configuração do workspace deste projeto em vez da configuração global. |
Descrição 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
| Flag | Padrão | Descrição |
|---|---|---|
--upgrade | false | Lê cada repositório por inteiro, sem comparar nada com o índice já gravado (uma atualização sem esta opção já relê tudo o que mudou) |
O que registry update informa sobre marcadores de descontinuação
Enquanto percorre um registry, aggrega registry update lê os marcadores de descontinuação de cada versão publicada e registra no índice local aqueles que consegue autenticar. Ele informa o resultado dessa varredura em todos os caminhos, para que um registry que não publicou nenhum marcador possa ser distinguido de uma execução que não procurou nenhum.
Cada marcador que a varredura lê produz uma linha que nomeia o repositório, a versão e a severidade que o publicador registrou — warning, error ou retracted — junto com a indicação de se o marcador foi registrado. Uma versão cujos anexos não mudaram desde a última atualização é mantida como registrada em vez de lida, então seu marcador não é informado novamente; a contagem abaixo ainda a inclui. Um marcador só é registrado quando sua própria assinatura é verificada em relação aos signatários que a política de confiança do registry aceita. Um que está presente mas não decodifica, ou presente mas não aceito, é informado como tal e deixado fora do índice em vez de registrado com base em evidências que não puderam ser autenticadas — e o mesmo vale para um que o registry responde que não tem. Um marcador cuja leitura falhou é um caso diferente: consulte Uma leitura que falha.
Em seguida, cada registry informa quantos marcadores seu índice registra agora, inclusive quando esse número é zero. Onde a verificação de assinaturas está desativada — globalmente ou para aquele único registry —, o percurso informa, em vez disso, que os marcadores não foram examinados para ele. São fatos diferentes: o primeiro diz que o registry não publicou nada sobre o que este workspace possa agir, o segundo diz que esta execução não tinha nenhuma base de confiança para julgar um marcador. Um registry cujos marcadores não foram examinados não contribui com nenhuma retirada para a seleção de versões, então um autor que anexou um marcador e vê essa linha sabe por que ele não tem efeito.
A data de publicação que cada versão registra
O horário de criação de um manifest publicado é fixado, então seu digest depende apenas do que é publicado e nunca de quando. A data em que uma versão foi publicada é, portanto, lida ao lado do manifest, e aggrega registry update a registra para cada versão com a fonte de onde veio:
transparency-log— onde a assinatura da versão é keyless e é verificada em relação à política de confiança do registry, o horário em que o log de transparência registrou essa assinatura, atestado pela promessa assinada do log. Onde várias assinaturas da versão são verificadas, é o mais antigo dos seus horários, e o assinante registrado para a versão é o dessa mesma assinatura — seja qual for a ordem em que o registry lista as assinaturas —, então uma versão assinada novamente mantém sua data e seu assinante. Para uma versão assinada ao ser publicada, essa é a sua publicação; para uma assinada pela primeira vez depois comaggrega sign, é quando foi assinada. Essa fonte prevalece onde quer que exista.publisher— caso contrário, o horário que a publicação declarou ao lado do que publicou: um pequeno anexo published-at queaggrega pusheaggrega push-artifactescrevem com o próprio relógio da máquina que publica, que nada atesta. Ele é lido de qualquer registry, seja qual for sua política de confiança, porque é a declaração do publicador, e não uma decisão de confiança. Onde vários estão anexados, o mais antigo é usado.
Uma versão sem nenhum dos dois não registra data. É uma publicação que não declarou nenhuma, onde sua assinatura não é uma keyless que esta política verifica — por exemplo, uma publicação keyless lida sob uma política que não confia em nenhuma identidade keyless, já que uma publicação keyless não declara nenhuma data própria. aggrega search -o json informa a data sob cada versão em published.
O que uma atualização relê
Uma atualização compara o que o registry serve agora com o que o índice registrou, e relê tudo o que mudou — a mesma resposta que uma releitura completa dá. Para cada repositório, ela:
- revalida a listagem de tags, de modo que uma versão publicada ou excluída desde então é detectada;
- resolve a tag de cada versão para o manifest que ela nomeia, de modo que uma versão mais antiga publicada novamente sob sua tag existente é relida;
- revalida os anexos de cada versão — suas assinaturas, suas declarações de data de publicação e seus marcadores de descontinuação — de modo que uma assinatura, uma data ou um marcador anexado a uma versão desde então é lido e verificado, e faz o mesmo com as assinaturas de um marcador de descontinuação que já avaliou antes;
- compara a política de confiança do registry com aquela sob a qual o índice foi construído, de modo que uma mudança na política faz reler cada versão sob a nova.
Um marcador de descontinuação, uma assinatura e uma data de publicação são, cada um, anexados a uma versão publicada como um objeto separado que aponta de volta para ela — o que permite a um publicador descontinuar ou assinar uma versão sem publicá-la novamente —, então nenhum deles adiciona uma tag ou altera o próprio manifest da versão. Eles alteram os anexos da versão, e é isso que a terceira verificação revalida. A exclusão de versões e aggrega inspect leem ambos este índice, então uma versão retirada desde a última atualização é excluída da seleção, e exibida, assim que a atualização seguinte tiver sido executada.
Cada verificação é uma pequena requisição — a resolução do digest de um manifest, ou uma requisição condicional que o registry responde como inalterada sem enviar nada —, então a atualização de um registry inalterado não baixa nada. Uma versão que traz um marcador de descontinuação que não foi aceito, ou cujos anexos esta execução não teve como revalidar, é relida na próxima atualização. Um registry que não consegue dizer se os anexos de uma versão mudaram faz cada versão ser relida a cada atualização: a resposta é a mesma, e o custo de uma releitura completa também.
--upgrade lê cada repositório por inteiro, sem comparar nada com o índice já gravado. Use-o para reconstruir um índice apenas a partir do registry; ele não detecta nada que uma atualização deixe passar.
Um registry que pede para desacelerar
O hub oficial, hub.aggrega.ai, limita quantas requisições podem vir de um mesmo endereço em um curto intervalo, de modo que máquinas que compartilham um endereço compartilham essa cota, e qualquer registry pode limitar seus clientes da mesma forma. Um registry que passou do seu limite responde 429 Too Many Requests, ou 503 Service Unavailable com um cabeçalho Retry-After dizendo quanto tempo esperar. Toda requisição que a linha de comando faz a um registry, qualquer que seja o comando, reage a essa resposta da mesma forma: aguarda o tempo que o registry pediu, ou dez segundos quando a resposta não diz, mais até um segundo extra aleatório, e então pede de novo, sem um número fixo de tentativas. Toda requisição a esse registry aguarda junto, não apenas a recusada, e menos requisições são enviadas a ele ao mesmo tempo — metade a cada vez que ele pede, até chegar a uma —, número que volta a subir de um em um após cada série de requisições que ele atende sem falhar, até o número habitual do comando. A espera é mostrada nos mesmos termos que o restante do progresso do comando, como uma linha do tipo hub.aggrega.ai asked to slow down; waiting 11 s: aggrega build, aggrega pull e aggrega registry update a mostram ao lado da etapa em andamento, os demais comandos que mostram o que estão aguardando a mostram como uma etapa própria — exceto aggrega sign --jobs assinando várias referências ao mesmo tempo, que mostra essas esperas como uma única etapa — e nada é mostrado quando a saída de erro padrão não é um terminal, a menos que o --progress do comando peça. Um registry que por cinco minutos não responde nada além de “desacelere” é recusado com E0378, indicando o registry, sua última resposta e há quanto tempo não respondia outra coisa; os cinco minutos são fixos, e nenhuma configuração os altera. aggrega registry update então nomeia esse registry em Not indexed: no resumo final, e o registry mantém o índice que tinha antes da execução.
Uma leitura que falha
Uma varredura lê muitos objetos pequenos de um registry, e algumas leituras falham ocasionalmente: o registry responde que falhou ou está indisponível (um status 5xx, exceto um 503 que diz quanto tempo esperar) ou que a requisição expirou (um 408), a conexão é redefinida ou expira, ou uma resposta é interrompida antes de estar completa. Cada uma dessas leituras é solicitada novamente algumas vezes, com uma espera crescente entre as tentativas. Um registry que pede à varredura para desacelerar não está fazendo uma leitura falhar: a leitura aguarda e é solicitada novamente como descreve Um registry que pede para desacelerar, e um registry que continua pedindo isso por cinco minutos encerra a varredura desse registry, e não a de um único repositório.
Uma leitura que continua falhando nunca é tomada como resposta. Uma assinatura que não pôde ser lida não é uma versão sem assinatura, e um marcador de descontinuação que não pôde ser lido não é uma versão que nunca foi retirada, então a varredura não registra nada sobre esse repositório nesta execução. O repositório mantém o registro que o índice já tem para ele, quando esse registro foi avaliado sob a política de confiança do registry agora em vigor, e caso contrário é deixado fora do índice. Em ambos os casos, a varredura nomeia o repositório em seus comentários durante a execução, dizendo qual dos dois casos ocorreu e qual leitura falhou, e o nomeia novamente em seu resumo final, em uma linha própria sob a linha do seu registry, entre os repositórios que não puderam ser lidos:
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: …A linha do registry também informa quantas leituras foram solicitadas novamente, cada leitura contada uma única vez, independentemente de quantas tentativas levou e de ter tido sucesso ou não depois, e informa 0 reads retried quando nenhuma foi. Uma varredura cujas leituras acabaram todas tendo sucesso não mostra nenhum repositório em sua linha, então é essa contagem que diz o quão perto ela chegou de deixar um de fora.
Cada uma dessas linhas começa com o tipo da última falha da leitura — o status com que o registry respondeu, uma leitura que expirou, uma conexão que foi redefinida ou uma resposta interrompida — seguido da própria falha, que diz qual leitura era. Uma falha que não é de nenhum desses tipos, como uma raiz de confiança que não pôde ser obtida para verificar uma assinatura com ela, é dada apenas como a falha. O método aggrega/registryUpdate do aggrega serve responde com os mesmos repositórios sob skipped de cada host, cada um com o mesmo reason, e com a contagem de leituras solicitadas novamente como readsRetried. O mesmo vale para uma atualização e para --upgrade, e a próxima varredura começa do que o índice contém então, como acontece com qualquer repositório.
A chave pública que uma política keyed fixa
Uma política de confiança keyed fixa a chave pública do registry inline, como a public_key da entrada: aggrega registry add --key <file> copia o conteúdo do arquivo para lá, e o mesmo faz a fixação de uma política que o registry anuncia com uma chave nela. O valor é um bloco PEM de chave pública — o texto desde uma linha -----BEGIN PUBLIC KEY-----, ou -----BEGIN RSA PUBLIC KEY-----, até a linha -----END correspondente —, e qualquer texto acima do bloco é ignorado.
Um valor sem nenhuma linha -----BEGIN … PUBLIC KEY----- é recusado quando o arquivo de configuração é carregado, nomeando o arquivo e a entrada. registry add faz a mesma verificação antes de escrever, então um arquivo --key contendo qualquer outra coisa — uma chave privada, um certificado ou uma chave em outra codificação — é recusado e o arquivo de configuração fica como estava. Somente essa linha é verificada: se o bloco é decodificado em uma chave utilizável só se descobre quando uma assinatura do registry é verificada em relação a ele.
Offline
aggrega registry update é o único comando deste grupo cujo trabalho inteiro é um percurso pelos registries e, no modo offline — a chave de nível superior offline em um arquivo de configuração, AGGREGA_OFFLINE ou --offline —, ele recusa antes de percorrer qualquer coisa. A recusa nomeia qual das três fontes definiu o modo.
Não há forma parcial à qual recorrer, porque o índice registra o que cada registry serve atualmente, e isso não pode ser descoberto sem perguntar a um. O que um workspace offline pode fazer é ler o índice que já tem: aggrega search e o aviso de descontinuação de aggrega inspect leem ambos o snapshot local e não precisam de rede alguma, então uma atualização é a única coisa que o modo tira. Para atualizar em uma execução a partir de um workspace offline, passe --offline=false.
aggrega registry add acessa a rede uma única vez, para a política de confiança que o registry anuncia, a menos que --fetch-trust=false, --identity ou --key digam para não buscar. No modo offline essa busca é recusada antes de qualquer conexão, então o registry nunca é consultado. Adicionar um registry diferente do hub oficial é então recusado — adicionar um registry é o único momento em que sua confiança é fixada, e uma entrada escrita sem a política não confiaria em nada enquanto cada pull posterior submeteria o registry a ela. A recusa traz o código curto E0310 e nomeia os dois caminhos possíveis: registrá-lo uma vez enquanto estiver online, o que --offline=false permite para uma execução, ou fixar a política manualmente com --identity ou --key, o que registra exatamente o que você fornece e não faz nenhuma busca. O hub oficial é adicionado com sua baseline embutida, com um aviso dizendo que o hub não foi consultado sobre sua política de confiança porque o workspace está offline e que a baseline é usada em seu lugar, e --fetch-trust=false registra a entrada a partir de seus flags exatamente como faz online. O mesmo registro feito por meio de aggrega serve ou aggrega mcp se comporta da mesma forma: a mesma recusa com as mesmas palavras e, de resto, a mesma entrada. A registry is added offline with no trust policy to pin (Um registry é adicionado offline sem nenhuma política de confiança a fixar) cita a recusa.
list e remove alteram ou leem a configuração local e não são afetados.