@microteia/console 2.21.0 → 2.22.1

package/CONSOLE-VERSIONS.md

@@ -22,6 +22,28 @@
 - fix(command): what was broken, and what it did to whoever hit it.
 -->
 
+#### [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.22.1
 
 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/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.22.1";

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.22.1';

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.22.1",
   "description": "Install and update Microteia in a Firebase project you own.",
   "license": "UNLICENSED",
   "type": "module",