@microteia/console 2.21.0 → 2.23.0

package/CONSOLE-VERSIONS.md

@@ -22,6 +22,32 @@
 - fix(command): what was broken, and what it did to whoever hit it.
 -->
 
+#### [2.23.0] — 2026-10-07
+
+- fix(provision): `microteia provision` run on its own now probes the deployed stamps itself instead of concluding that nothing changed. It could only compare stamps with the map `deploy` hands it, and running alone — the path of anyone who has just swapped kernels with `unpack` — there was no map: `outdatedByStamp` drew no conclusion, the function stayed out of the queue, and the record said "applied" because it genuinely was running, from the previous package. An office upgraded this way kept serving an extension's old Cloud Function with nothing anywhere saying so; the symptom surfaced in the client, not in the Console. The queue is now everything the installed extensions claim, and `deployFunctionsThatChanged` — the same probe `deploy` uses — decides what actually goes up: one reference function per stamp, and the rest left alone when it comes back unchanged. What the probe skips counts as satisfied, or a complete installation would stay "pending" forever.
+
+#### [2.22.1] — 2026-09-19
+
+- fix(cli/publish): the release notes now carry every changelog entry since the last PUBLISHED version,
+  not only the one being packaged. A version can be packaged and never published — the catalog is what
+  says what went up, and the package being published contains all of them. Publishing 9.66.0 over a
+  catalog whose newest entry was 9.64.0 created a release that carries 9.65.0 and did not quote a line
+  of it, and a release is immutable: no later release goes back to tell what those versions changed.
+  The cut now starts at `publishedBefore(index, version)`, so it happens after the catalog is read
+  rather than while the package is; the first publish, which has no interval, still cuts its own entry
+  alone. The command prints which versions the notes carry, in the dry run too.
+
+#### [2.22.0] — 2026-09-10
+
+- feat(deploy): the reachability check now covers HTTP endpoints, not only callables.
+  `callableFunctionNames` matches `onRequest` as well, because the list means "what the outside world
+  calls" and an HTTP endpoint depends on public invocation even more than a callable does — a blocked
+  invoker grant answers 403 with no CORS header, and the client reports a connection error. Without
+  this, the platform's first `onRequest` would have gone up unverified.
+- fix(deploy): the `functions-invoker` prerequisite no longer promises that every reachable function
+  rejects a caller with no signed-in user. That is true of a callable and false of an endpoint that
+  authenticates by token, and the sentence was about to be read by whoever installs the agent access.
+
 #### [2.21.0] — 2026-09-09
 
 - fix(cli/pack): reading-only examples are left out of the first-party backend accounting.

package/README.md

@@ -1,4 +1,4 @@
-# Microteia Console 2.21.0
+# Microteia Console 2.23.0
 
 Installs and updates Microteia in a Firebase project you own. It has no npm dependencies of its own —
 what it needs are command-line tools that are already on the machine, listed at the bottom.

package/lib/console/provision.js

@@ -10,6 +10,7 @@ import { changedParameters, functionsDeclaringParameters, parameterDigests, pars
 import { ENVIRONMENT_FILE, readEnvironment, writeEnvironment } from './environment.js';
 import { FIREBASE_BIN } from './firebaseCli.js';
 import { deployFunctionsOneByOne, reportFailures, reportNotices } from './deployFunctions.js';
+import { deployFunctionsThatChanged } from './functionsUpToDate.js';
 import { clearRegionOrphans, listDeployedFunctions } from './regionOrphans.js';
 import { outdatedByStamp } from './functionsUpToDate.js';
 import { checkCallables, invokerGrantCommand } from './callableAccess.js';
@@ -363,7 +364,28 @@ export const provisionBackend = async (options) => {
         info('  Cloud Function at ITS deploy, so a function already running keeps the previous one.');
         blank();
     }
-    const queued = wantedFunctions.filter((name) => options.all === true || !appliedNames.has(name) || staleFunctions.has(name));
+    /**
+     * De onde vem a conclusão sobre o que mudou — e são DOIS caminhos, porque as duas situações são
+     * diferentes de verdade.
+     *
+     * Vindo do `deploy`, o carimbo de agora já foi observado: as functions do kernel acabaram de subir,
+     * e as de extensão estão no MESMO codebase, então `outdatedByStamp` decide sem sondar nada.
+     *
+     * Rodando SOZINHO — que é o caminho de quem acabou de trocar de kernel por `unpack` — não há mapa
+     * nenhum, e era aqui que estava o defeito: `outdatedByStamp` não tinha com o que comparar, não
+     * tirava conclusão, e a function de extensão cujo CÓDIGO mudou ficava de fora da fila para sempre.
+     * O registro dizia "aplicada", porque ela de fato estava no ar — só que da versão anterior. Nada
+     * avisava, e o sintoma aparecia no cliente, não aqui.
+     *
+     * Então a fila passa a ser TUDO o que as extensões pedem, e quem decide o que realmente sobe é
+     * `deployFunctionsThatChanged` — a mesma sondagem do `deploy`, pela mesma função: deploya uma
+     * referência por carimbo e, se o carimbo voltar igual, deixa as outras em paz. Custa uma function
+     * por execução; não custar nada era o que fazia a conta ficar errada.
+     */
+    const probing = options.refreshedStamps === undefined;
+    const queued = probing
+        ? wantedFunctions
+        : wantedFunctions.filter((name) => options.all === true || !appliedNames.has(name) || staleFunctions.has(name));
     /**
      * A recusa do portão, cobrada de quem está na fila — e só dela.
      *
@@ -382,6 +404,8 @@ export const provisionBackend = async (options) => {
         info('  they are the only ones held back. Fix the guard and run "microteia provision" again.');
         outcome.failed.push(...refused);
     }
+    /** O que já estava no ar com ESTE código, e por isso não subiu. Conta como satisfeito. */
+    let skippedNow = [];
     if (toDeploy.length === 0) {
         // Anunciar "as 0 functions já estão deployadas" seria o preço de ter tirado o desvio, e não é
         // preciso pagá-lo: quando não há exigência nenhuma, quem já falou foi a linha lá em cima.
@@ -405,17 +429,27 @@ export const provisionBackend = async (options) => {
         // A extensão que mudou de região deixa a cópia antiga para trás igual ao kernel, e ali o efeito
         // é o mesmo: deploy recusado em toda tentativa, e gatilho disparando em duas regiões.
         await clearRegionOrphans(projectId, toDeploy, region, options.prune, await projectFunctions());
-        info(`  deploying ${toDeploy.length} function(s), one at a time…`);
-        const report = await deployFunctionsOneByOne(toDeploy, {
-            projectId, cwd: install, delaySeconds, force: false,
-        });
+        const deployOptions = { projectId, cwd: install, delaySeconds, force: false };
+        if (!probing)
+            info(`  deploying ${toDeploy.length} function(s), one at a time…`);
+        const report = probing
+            ? await deployFunctionsThatChanged(toDeploy, deployOptions, {
+                deployed: await projectFunctions(),
+                region,
+                all: options.all === true,
+            })
+            : { ...await deployFunctionsOneByOne(toDeploy, deployOptions), skipped: [] };
+        skippedNow = report.skipped;
         outcome.deployed = report.deployed;
         outcome.failed.push(...report.failed.map((entry) => entry.name));
         reportFailures(report.failed);
         reportNotices(report.notices);
         await checkNewCallables([...(manifest.callables ?? []), ...office.callables], report.deployed, projectId, region);
     }
-    const deployedNow = new Set([...appliedNames, ...outcome.deployed]);
+    // O PULADO entra junto: ele não subiu agora porque o projeto já roda exatamente este código, que é
+    // o mesmo que estar satisfeito. Deixá-lo de fora manteria a extensão "pendente" para sempre numa
+    // instalação em que não falta nada.
+    const deployedNow = new Set([...appliedNames, ...outcome.deployed, ...skippedNow]);
     for (const claim of valid) {
         const satisfied = (claim.backend.functions ?? []).every((name) => deployedNow.has(name));
         if (satisfied) {

package/lib/kernel/channel.d.ts

@@ -70,6 +70,17 @@ export declare const entryOf: (manifest: KernelManifest, urls: {
  * `9.8.2` significa. Um número novo custa um minuto.
  */
 export declare const withEntry: (index: ChannelIndex, entry: ChannelEntry) => ChannelIndex;
+/**
+ * A última versão publicada ABAIXO desta — o começo do intervalo que o release novo cobre.
+ *
+ * É "abaixo desta" e não "o topo do catálogo" porque publicar fora de ordem é possível, e o que o
+ * release precisa descrever é o que ele acrescenta a quem já tinha a anterior. Quem já tinha a anterior
+ * está na maior versão MENOR que esta.
+ *
+ * Nada publicado ainda é `undefined`, e não a menor versão do histórico: o arquivo de histórico começa
+ * antes do catálogo, e a primeira publicação não descreve o que veio antes dela.
+ */
+export declare const publishedBefore: (index: ChannelIndex, version: string) => string | undefined;
 /**
  * Resolve o que foi pedido — `latest` ou um número — nomeando o que existe quando não acha.
  *

package/lib/kernel/channel.js

@@ -126,6 +126,20 @@ export const withEntry = (index, entry) => {
         kernel: [entry, ...index.kernel].sort(byVersionDescending),
     };
 };
+/**
+ * A última versão publicada ABAIXO desta — o começo do intervalo que o release novo cobre.
+ *
+ * É "abaixo desta" e não "o topo do catálogo" porque publicar fora de ordem é possível, e o que o
+ * release precisa descrever é o que ele acrescenta a quem já tinha a anterior. Quem já tinha a anterior
+ * está na maior versão MENOR que esta.
+ *
+ * Nada publicado ainda é `undefined`, e não a menor versão do histórico: o arquivo de histórico começa
+ * antes do catálogo, e a primeira publicação não descreve o que veio antes dela.
+ */
+export const publishedBefore = (index, version) => [...index.kernel]
+    .sort(byVersionDescending)
+    .find((entry) => compareVersions(entry.version, version) < 0)
+    ?.version;
 /**
  * Resolve o que foi pedido — `latest` ou um número — nomeando o que existe quando não acha.
  *

package/lib/kernel/manifest.d.ts

@@ -127,10 +127,20 @@ export declare const MANUAL_PREREQUISITES: KernelPrerequisite[];
  */
 export declare const exportedFunctionNames: (indexSource: string) => string[];
 /**
- * As callables são as functions que o NAVEGADOR chama. Elas se distinguem das de gatilho por uma
- * razão prática: só elas podem ser verificadas de fora, e só nelas a permissão de invocação pública
- * importa. Sem ela a aplicação abre e toda chamada ao servidor falha — parecendo erro de CORS, que
- * manda procurar no lugar errado.
+ * As functions que o mundo de FORA chama — e é isso que a lista significa, não o construtor delas.
+ *
+ * Elas se distinguem das de gatilho por uma razão prática: só elas podem ser verificadas de fora, e
+ * só nelas a permissão de invocação pública importa. Sem ela a aplicação abre e toda chamada ao
+ * servidor falha — parecendo erro de CORS, que manda procurar no lugar errado.
+ *
+ * `onRequest` entra pela MESMA razão, e não por generosidade: um endpoint HTTP é ainda mais
+ * dependente da invocação pública que uma callable, porque quem o consome pode não ser um navegador
+ * nosso — é o caso do endpoint MCP, que um cliente de IA chama. O preflight de `callableAccess`
+ * serve os dois sem mudar uma linha: ele pergunta `OPTIONS` e confere o cabeçalho de CORS, que um
+ * `onRequest` com `cors: true` responde igual.
+ *
+ * O que NÃO se confunde com isto é o portão de instalação (`functionGate`): lá a distinção entre
+ * `onCall` e `onRequest` importa muito, porque uma tem escritório no chamador e a outra não.
  */
 export declare const callableFunctionNames: (source: string) => string[];
 /**

package/lib/kernel/manifest.js

@@ -86,7 +86,9 @@ export const MANUAL_PREREQUISITES = [
             + 'CORS error. The fix is one command per function, and the deploy prints the exact list: gcloud '
             + 'run services add-iam-policy-binding <function-name-in-lowercase> --region=<region> '
             + '--project=<projectId> --member=allUsers --role=roles/run.invoker. Unauthenticated invocation '
-            + 'is not open access: every callable still rejects callers with no signed-in user.',
+            + 'is not open access: reaching a function is not the same as being allowed to use it. A callable '
+            + 'rejects any caller with no signed-in user, and an HTTP endpoint authenticates every request '
+            + 'with the credential it was given and refuses everything else.',
         optional: true,
     },
     {
@@ -107,12 +109,23 @@ export const exportedFunctionNames = (indexSource) => [...indexSource.matchAll(/
     .map((name) => name.trim())
     .filter((name) => name !== '');
 /**
- * As callables são as functions que o NAVEGADOR chama. Elas se distinguem das de gatilho por uma
- * razão prática: só elas podem ser verificadas de fora, e só nelas a permissão de invocação pública
- * importa. Sem ela a aplicação abre e toda chamada ao servidor falha — parecendo erro de CORS, que
- * manda procurar no lugar errado.
+ * As functions que o mundo de FORA chama — e é isso que a lista significa, não o construtor delas.
+ *
+ * Elas se distinguem das de gatilho por uma razão prática: só elas podem ser verificadas de fora, e
+ * só nelas a permissão de invocação pública importa. Sem ela a aplicação abre e toda chamada ao
+ * servidor falha — parecendo erro de CORS, que manda procurar no lugar errado.
+ *
+ * `onRequest` entra pela MESMA razão, e não por generosidade: um endpoint HTTP é ainda mais
+ * dependente da invocação pública que uma callable, porque quem o consome pode não ser um navegador
+ * nosso — é o caso do endpoint MCP, que um cliente de IA chama. O preflight de `callableAccess`
+ * serve os dois sem mudar uma linha: ele pergunta `OPTIONS` e confere o cabeçalho de CORS, que um
+ * `onRequest` com `cors: true` responde igual.
+ *
+ * O que NÃO se confunde com isto é o portão de instalação (`functionGate`): lá a distinção entre
+ * `onCall` e `onRequest` importa muito, porque uma tem escritório no chamador e a outra não.
  */
-export const callableFunctionNames = (source) => [...source.matchAll(/export\s+const\s+([a-zA-Z0-9_]+)\s*=\s*onCall\b/g)].map((match) => match[1]);
+export const callableFunctionNames = (source) => [...source.matchAll(/export\s+const\s+([a-zA-Z0-9_]+)\s*=\s*(?:onCall|onRequest)\b/g)]
+    .map((match) => match[1]);
 /**
  * Os parâmetros que o backend declara com `defineString`. O `firebase-functions` os valida
  * GLOBALMENTE, e não por function: um parâmetro sem valor e sem default recusa o deploy de TODAS as

package/lib/shared/paths.d.ts

@@ -87,4 +87,4 @@ export declare const consoleRoot: string;
  * de código nunca chegou a quem instala. Este bloco fica sendo o que ele já era antes de crescer: a
  * política de semver da ferramenta, mais o registro do que motivou as versões até a `2.5.0`.
  */
-export declare const CLI_VERSION = "2.21.0";
+export declare const CLI_VERSION = "2.23.0";

package/lib/shared/paths.js

@@ -94,4 +94,4 @@ export const consoleRoot = resolve(here, '..', '..');
  * de código nunca chegou a quem instala. Este bloco fica sendo o que ele já era antes de crescer: a
  * política de semver da ferramenta, mais o registro do que motivou as versões até a `2.5.0`.
  */
-export const CLI_VERSION = '2.21.0';
+export const CLI_VERSION = '2.23.0';

package/lib/vendor/changelogs.d.ts

@@ -38,16 +38,28 @@ export declare const changelogProblems: (file: string, contents: string, version
  */
 export declare const readChangelog: (directory: string, file: string, version: string) => Promise<string>;
 /**
- * A entrada de UMA versão, para ser o corpo do release publicado.
+ * As entradas que o release publicado carrega: a da versão que está saindo, e a de TODA versão entre ela
+ * e a última já publicada.
  *
  * O texto do release não é escrito à mão em lugar nenhum: ele é o mesmo parágrafo que já foi conferido
  * pelo `pack`, recortado daqui. Dois textos sobre a mesma versão divergem — e o que divergiria é
  * justamente o que fica visível para quem procura o que mudou.
  *
- * Recorta do cabeçalho da versão até o próximo cabeçalho, e não até o fim: o que vem depois é o
- * histórico anterior, e ele já está publicado nos releases dele.
+ * O recorte de uma entrada só perdia o intervalo. Publicar a 9.66.0 quando a última publicada é a
+ * 9.64.0 — porque a 9.65.0 foi empacotada e não subiu — entrega um release que CONTÉM a 9.65.0 e não
+ * menciona uma linha dela: para quem procura o que mudou, aquelas alterações nunca existiram, e não há
+ * release posterior que as traga de volta. O release descreve o que ele leva, e ele leva tudo desde a
+ * última publicação.
+ *
+ * Sem `since` é a primeira publicação, e aí o recorte é só da própria versão: o histórico do arquivo é
+ * anterior ao catálogo, e despejá-lo inteiro não seria descrever o que subiu.
  */
-export declare const changelogEntry: (contents: string, version: string) => string;
+export interface ChangelogNotes {
+    body: string;
+    /** As versões recortadas, da mais recente para a mais antiga — o que o release diz que cobre. */
+    versions: string[];
+}
+export declare const changelogEntries: (contents: string, version: string, since?: string) => ChangelogNotes;
 export interface ChangelogRefresh {
     written: string[];
     missing: string[];

package/lib/vendor/changelogs.js

@@ -83,26 +83,25 @@ export const readChangelog = async (directory, file, version) => {
     }
     return contents;
 };
-/**
- * A entrada de UMA versão, para ser o corpo do release publicado.
- *
- * O texto do release não é escrito à mão em lugar nenhum: ele é o mesmo parágrafo que já foi conferido
- * pelo `pack`, recortado daqui. Dois textos sobre a mesma versão divergem — e o que divergiria é
- * justamente o que fica visível para quem procura o que mudou.
- *
- * Recorta do cabeçalho da versão até o próximo cabeçalho, e não até o fim: o que vem depois é o
- * histórico anterior, e ele já está publicado nos releases dele.
- */
-export const changelogEntry = (contents, version) => {
+export const changelogEntries = (contents, version, since) => {
     const body = withoutTemplates(contents);
     const headings = [...body.matchAll(ENTRY)];
-    const index = headings.findIndex((match) => match[1] === version);
-    if (index === -1) {
+    const first = headings.findIndex((match) => match[1] === version);
+    if (first === -1) {
         throw new Error(`The changelog has no entry for ${version}.`);
     }
-    const start = headings[index].index;
-    const end = index + 1 < headings.length ? headings[index + 1].index : body.length;
-    return `${body.slice(start, end).trim()}\n`;
+    let last = first;
+    while (since !== undefined
+        && last + 1 < headings.length
+        && compareVersions(headings[last + 1][1], since) > 0) {
+        last += 1;
+    }
+    const start = headings[first].index;
+    const end = last + 1 < headings.length ? headings[last + 1].index : body.length;
+    return {
+        body: `${body.slice(start, end).trim()}\n`,
+        versions: headings.slice(first, last + 1).map((match) => match[1]),
+    };
 };
 /**
  * Põe os dois históricos na raiz da instalação, SOBREPONDO — pela mesma razão que o `MICROTEIA.md` é

package/lib/vendor/exampleSources.js

@@ -32,6 +32,7 @@ const EXAMPLES_DIR = 'examples';
  */
 export const EXAMPLE_SOURCES = {
     'automation-example': 'examples/automation-example',
+    agent: 'agent.ts',
     brasil: 'brasil.ts',
     calendar: 'calendar.ts',
     dashboard: 'dashboard.ts',

package/lib/vendor/publish.js

@@ -6,8 +6,8 @@ import { CLI_VERSION, repoRoot } from '../shared/paths.js';
 import { capture, captureOrThrow, run } from '../shared/run.js';
 import { blank, bullets, heading, info, pending, step, success, warn } from '../shared/ui.js';
 import { digestMismatch, digestOfFile } from '../shared/digest.js';
-import { emptyIndex, entryOf, kernelTarballName, parseIndex, serializeIndex, withEntry, } from '../kernel/channel.js';
-import { CONSOLE_CHANGELOG, KERNEL_CHANGELOG, changelogEntry, readChangelog } from './changelogs.js';
+import { emptyIndex, entryOf, kernelTarballName, parseIndex, publishedBefore, serializeIndex, withEntry, } from '../kernel/channel.js';
+import { CONSOLE_CHANGELOG, KERNEL_CHANGELOG, changelogEntries, readChangelog } from './changelogs.js';
 import { CONSOLE_PACKAGE_NAME } from './packageTemplates.js';
 import { assertInsideRepository } from './repository.js';
 /**
@@ -170,20 +170,30 @@ const readKernelPackage = async (root, version) => {
             + 'One of the two was rebuilt without the other. Run "npm run pack:kernel" again.');
     }
     const changelog = await readChangelog(root, KERNEL_CHANGELOG, version);
-    return { manifest, tarball, entry: changelogEntry(changelog, version) };
+    return { manifest, tarball, changelog };
 };
 const publishKernel = async (root, version, repo, dryRun) => {
     await assertGitHubCli();
-    const { manifest, tarball, entry } = await readKernelPackage(root, version);
+    const { manifest, tarball, changelog } = await readKernelPackage(root, version);
     const directory = join(root, 'distributions', 'kernel', version);
     const manifestPath = join(directory, 'manifest.json');
     const published = await readPublishedIndex(repo);
+    /**
+     * O corpo do release cobre o INTERVALO, e não só a versão que está saindo. Um pacote leva tudo o que
+     * veio antes dele; um release que só cita a própria entrada esconde as versões que foram empacotadas e
+     * não publicadas, e nenhum release posterior volta para contá-las.
+     */
+    const since = publishedBefore(published.index, version);
+    const notes = changelogEntries(changelog, version, since);
     const next = withEntry(published.index, entryOf(manifest, {
         tarball: assetUrl(repo, version, kernelTarballName(version)),
         manifest: assetUrl(repo, version, 'manifest.json'),
     }, new Date().toISOString()));
     success(`kernel ${version} verified: ${manifest.tarball?.bytes} bytes, sha256 ${manifest.tarball?.sha256.slice(0, 12)}…`);
     info(`  tag ${tagOf(version)} in ${repo}, and ${INDEX_PATH} promoting it to "latest"`);
+    info(notes.versions.length === 1
+        ? `  release notes: the ${version} entry of ${KERNEL_CHANGELOG}`
+        : `  release notes: ${notes.versions.join(', ')} — every entry since ${since ?? 'the first one'}`);
     if (dryRun) {
         if (published.empty)
             info(`  ${repo} has no commits, so it would be seeded with a README first`);
@@ -192,9 +202,9 @@ const publishKernel = async (root, version, repo, dryRun) => {
     }
     if (published.empty)
         await seedRepository(repo);
-    const notes = await mkdtemp(join(tmpdir(), 'microteia-publish-'));
-    const notesFile = join(notes, 'notes.md');
-    await writeFile(notesFile, entry);
+    const notesRoot = await mkdtemp(join(tmpdir(), 'microteia-publish-'));
+    const notesFile = join(notesRoot, 'notes.md');
+    await writeFile(notesFile, notes.body);
     try {
         if (await releaseExists(repo, version)) {
             /**
@@ -224,7 +234,7 @@ const publishKernel = async (root, version, repo, dryRun) => {
         success(`${INDEX_PATH} updated — "microteia unpack --version latest" now takes ${version}`);
     }
     finally {
-        await rm(notes, { recursive: true, force: true });
+        await rm(notesRoot, { recursive: true, force: true });
     }
 };
 const publishedConsoleVersion = async (version) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microteia/console",
-  "version": "2.21.0",
+  "version": "2.23.0",
   "description": "Install and update Microteia in a Firebase project you own.",
   "license": "UNLICENSED",
   "type": "module",