@microteia/console 2.38.0 → 2.42.0

package/lib/console/provision.js

@@ -19,6 +19,7 @@ import { pendingCauseOf } from './backendPending.js';
 import { settlePackagedSources } from './packagedApproval.js';
 import { clearPackagedSources, packagedSourceOf, parseApprovals } from './packagedSources.js';
 import { writeBackendResidue } from './backendResidue.js';
+import { appliedEntryOf, readBackendApplied, reduceBackendApplied, writeBackendApplied, } from './backendApplied.js';
 import { listTenants, readInstalledExtensions } from './installedExtensions.js';
 import { gatherCustomFunctions, readOfficeFunctions } from './customFunctions.js';
 import { describeMisgated, gateProblems, misgatedTriggers, singleClaimants, } from './functionGate.js';
@@ -107,7 +108,9 @@ export const provisionBackend = async (options) => {
      * rejeitada com "this kernel package does not contain".
      */
     const survey = await surveyInstallations(projectId);
-    const claims = survey.claims;
+    const claims = await settleProjectApplied(projectId, survey.claims);
+    /** O que esta execução carimbou — é o que `backend_state/applied` passa a dizer no fim. */
+    const stamped = [];
     /**
      * A fonte que veio NO PACOTE é decidida antes de qualquer conta: o que for aprovado é extraído para
      * `.microteia/packaged-functions/` e passa a ser lido como qualquer fonte da instalação. A leitura
@@ -521,7 +524,7 @@ export const provisionBackend = async (options) => {
         // function que já estava aplicada continua satisfazendo a extensão mesmo que o portão dela tenha
         // saído da fila nesta execução.
         if (isValid && (claim.backend.functions ?? []).every((name) => deployedNow.has(name))) {
-            await stampApplied(projectId, claims, claim, settlement.approvedNow.get(claim.pluginId));
+            stamped.push(await stampApplied(projectId, claims, claim, settlement.approvedNow.get(claim.pluginId)));
             continue;
         }
         if (isValid)
@@ -582,8 +585,76 @@ export const provisionBackend = async (options) => {
     }), settled.declared);
     reportOrphanIndexes(projectId, settled.orphans, options.prune);
     await publishResidue(projectId, remaining, settled.orphans, survey);
+    await publishApplied(projectId, stamped);
     return outcome;
 };
+/**
+ * O documento do projeto, conciliado com as cópias ANTES de qualquer conta.
+ *
+ * Primeiro materializa: a cópia sem carimbo próprio cujo fingerprint o projeto já tem aplicado recebe o
+ * carimbo agora, com a aprovação que veio de lá — é o que este comando gravaria se tivesse rodado quando
+ * ela foi atualizada. A partir daí ela se comporta como qualquer cópia carimbada, e a redução logo
+ * abaixo pode tirar a entrada dela sem tirá-la do ar.
+ *
+ * Depois reduz, e a redução vem antes de deploy e de `--prune` de propósito: se a escrita falhar, o
+ * comando para AQUI, antes de mudar o projeto. Seguir adiante deixaria o documento anunciando no ar a
+ * function que o `--prune` estaria prestes a apagar.
+ */
+const settleProjectApplied = async (projectId, surveyed) => {
+    let entries = [];
+    try {
+        entries = await readBackendApplied(projectId);
+    }
+    catch (error) {
+        warn('could not read what this project already has applied:');
+        info(`  ${error instanceof Error ? error.message : String(error)}`);
+        info('  copies installed after the last run are not released early; this run stamps them as usual.');
+    }
+    const appliedAt = new Date();
+    const claims = [];
+    for (const claim of surveyed) {
+        const entry = claim.applied ? undefined : appliedEntryOf(entries, { pluginId: claim.pluginId, fingerprint: claimFingerprint(claim) });
+        if (entry === undefined) {
+            claims.push(claim);
+            continue;
+        }
+        await writeStamp(projectId, claim.documentPath, entry.fingerprint, appliedAt, approvalOf(entry.approvedHash, entry.approvedBy));
+        claims.push({
+            ...claim,
+            applied: true,
+            ...(entry.approvedHash !== undefined ? { approvedHash: entry.approvedHash } : {}),
+            ...(entry.approvedBy !== undefined ? { approvedBy: entry.approvedBy } : {}),
+        });
+    }
+    const newest = uniqueByPlugin(claims).map((claim) => ({ pluginId: claim.pluginId, fingerprint: claimFingerprint(claim) }));
+    try {
+        await writeBackendApplied(projectId, reduceBackendApplied(entries, newest));
+    }
+    catch (error) {
+        throw new Error('could not update what this project has applied before changing it, so nothing was changed.\n'
+            + `  ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+    return claims;
+};
+/**
+ * O que ficou aplicado, regravado por inteiro — inclusive vazio, que é o que apaga a entrada da extensão
+ * que saiu.
+ *
+ * Falhar aqui não derruba o comando, pela mesma razão do resíduo: o trabalho já foi feito. O documento
+ * fica como a redução o deixou, que só tem o que continua verdadeiro — o que se perde é o atalho, não a
+ * segurança.
+ */
+const publishApplied = async (projectId, stamped) => {
+    try {
+        await writeBackendApplied(projectId, stamped);
+    }
+    catch (error) {
+        warn('could not record what this project has applied where the application can read it:');
+        info(`  ${error instanceof Error ? error.message : String(error)}`);
+        info('  every copy installed now is stamped. A copy installed later stays pending until the next');
+        info('  "microteia provision".');
+    }
+};
 /**
  * O que sobrou, devolvido ao banco para a aplicação poder mostrá-lo.
  *
@@ -689,30 +760,44 @@ const stampApplied = async (projectId, all, claim, approvedNowBy) => {
      * cópia nova de um escritório que reinstalou, sem perguntar de novo pelo código que já roda.
      */
     const hash = claim.source?.hash;
-    const approval = hash === undefined
-        ? {}
-        : {
-            approvedHash: asString(hash),
-            approvedBy: asString(approvedNowBy
-                ?? all.find((entry) => entry.pluginId === claim.pluginId && entry.approvedHash === hash)?.approvedBy
-                ?? 'unknown'),
-            approvedAt: asTimestamp(appliedAt),
-        };
+    const approvedBy = hash === undefined
+        ? undefined
+        : approvedNowBy
+            ?? all.find((entry) => entry.pluginId === claim.pluginId && entry.approvedHash === hash)?.approvedBy
+            ?? 'unknown';
     for (const copy of all.filter((entry) => entry.pluginId === claim.pluginId)) {
         if (claimFingerprint(copy) !== fingerprint)
             continue;
-        // O motivo de uma recusa anterior sai na MESMA escrita: duas escritas abririam uma janela em que a
-        // tela mostra a extensão no ar e, ao mesmo tempo, por que ela não estava.
-        await patchFields(projectId, copy.documentPath, {
-            backendState: asMap({
-                fingerprint: asString(fingerprint),
-                appliedAt: asTimestamp(appliedAt),
-                ...approval,
-            }),
-            backendPending: asNull(),
-        });
+        await writeStamp(projectId, copy.documentPath, fingerprint, appliedAt, approvalOf(hash, approvedBy));
     }
     success(`${claim.name} is ready in ${projectId}`);
+    return {
+        pluginId: claim.pluginId,
+        fingerprint,
+        ...(hash !== undefined ? { approvedHash: hash } : {}),
+        ...(approvedBy !== undefined ? { approvedBy } : {}),
+    };
+};
+const approvalOf = (hash, by) => hash === undefined ? undefined : { hash, by: by ?? 'unknown' };
+/** O carimbo numa cópia — o mesmo vindo do deploy desta execução ou do que o projeto já tinha aplicado. */
+const writeStamp = async (projectId, documentPath, fingerprint, appliedAt, approval) => {
+    const approvalFields = approval === undefined
+        ? {}
+        : {
+            approvedHash: asString(approval.hash),
+            approvedBy: asString(approval.by),
+            approvedAt: asTimestamp(appliedAt),
+        };
+    // O motivo de uma recusa anterior sai na MESMA escrita: duas escritas abririam uma janela em que a
+    // tela mostra a extensão no ar e, ao mesmo tempo, por que ela não estava.
+    await patchFields(projectId, documentPath, {
+        backendState: asMap({
+            fingerprint: asString(fingerprint),
+            appliedAt: asTimestamp(appliedAt),
+            ...approvalFields,
+        }),
+        backendPending: asNull(),
+    });
 };
 /** O fingerprint que a cópia exige — o mesmo que a tela calcula, com o hash da fonte quando ela existe. */
 const claimFingerprint = (claim) => backendFingerprint(claim.backend, claim.source?.hash);

package/lib/index.js

@@ -89,7 +89,7 @@ const COMMANDS = [
     {
         name: 'publish',
         usage: 'microteia publish [--kernel-only|--console-only] [--repo <owner/name>] [--otp <code>] [--dry-run]',
-        summary: 'Release what pack and pack-console built, so an office can download it.',
+        summary: 'Release what pack and pack-console built, so an office can download it. Push first: the kernel is tagged on its commit.',
         audience: 'publisher',
         execute: publish,
     },

package/lib/kernel/manifest.d.ts

@@ -63,6 +63,14 @@ export interface KernelManifest {
      * para um arquivo que não existe.
      */
     sdk?: KernelSdk;
+    /**
+     * De que commit do repositório-fonte o pacote saiu. É lido pelo `pack` ANTES de qualquer build, e é
+     * o que o `publish` marca com a tag `kernel-<versão>` no repositório-fonte — sem ele, saber de que
+     * código veio um kernel publicado exigia adivinhar pelo histórico do `package.json`.
+     *
+     * Ausente nos pacotes anteriores a este campo e nos montados fora de um checkout git.
+     */
+    source?: KernelSource;
     /**
      * O tamanho e a impressão digital do tarball, presentes SÓ na cópia externa do manifesto — a que fica
      * ao lado do `.tgz` e é publicada com ele. A cópia de dentro do tarball não pode carregá-los: ela
@@ -74,6 +82,15 @@ export interface KernelManifest {
      */
     tarball?: KernelTarball;
 }
+export interface KernelSource {
+    commit: string;
+    /**
+     * Havia alteração não commitada quando o pacote foi montado. Nesse caso nenhum commit é a fonte do
+     * pacote, e o `publish` não marca nenhum: uma tag que aponta para código diferente do publicado é
+     * pior que tag nenhuma.
+     */
+    dirty: boolean;
+}
 export interface KernelTarball {
     /** O nome do arquivo, não um caminho: onde ele fica é decisão de quem publica. */
     name: string;

package/lib/kernel/manifest.js

@@ -141,20 +141,6 @@ export const MANUAL_PREREQUISITES = [
             + 'changes for anyone.',
         optional: true,
     },
-    {
-        id: 'self-service-tenants',
-        title: 'Stop sign-up from opening an organization, if this installation is shared',
-        detail: 'By default every new account gets an organization of its own, with that person as the owner. In an '
-            + 'installation shared by several organizations — each one created on purpose — that lets anyone who '
-            + 'can create an account open one. Write SELF_SERVICE_TENANTS=false in .env.<projectId> and run '
-            + 'microteia deploy --only functions: from then on a new account waits to be added to an organization, and only the '
-            + 'installation administrator (SYSTEM) opens organizations, in Access management > Organizations, '
-            + 'naming an owner who already has an account. The first account of the installation gets one '
-            + 'anyway. Any value other than empty, true or false is read as false. Two-step verification is '
-            + 'required per organization and does not reach the installation administrator: protect SYSTEM '
-            + 'accounts with a sign-in provider that enforces its own second factor.',
-        optional: true,
-    },
 ];
 /**
  * Os nomes das Cloud Functions saem de `functions/src/index.ts`, a mesma fonte e o mesmo parse que

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.38.0";
+export declare const CLI_VERSION = "2.42.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.38.0';
+export const CLI_VERSION = '2.42.0';

package/lib/vendor/installationDocs.js

@@ -197,7 +197,7 @@ setting:
 
 - **A setting of an extension, or of your own \`functions/\`** — run \`microteia provision\`. It notices the
   change (by a salted digest in \`microteia.yaml\`) and requeues exactly the functions that carry it.
-- **A setting of the platform itself** (\`SELF_SERVICE_TENANTS\`, \`AUDIT_ARCHIVE_BUCKET\`, …) — run
+- **A setting of the platform itself** (\`AUDIT_ARCHIVE_BUCKET\`, …) — run
   \`microteia deploy --only functions\`. \`provision\` does not track them; the deploy compares each
   function's stamp, which includes its environment, and redeploys the ones whose value changed.
 

package/lib/vendor/pack.js

@@ -2,7 +2,7 @@ import { cp, mkdir, readdir, readFile, rename, rm, writeFile } from 'node:fs/pro
 import { basename, join, relative } from 'node:path';
 import { flagValue, hasFlag } from '../shared/args.js';
 import { repoRoot } from '../shared/paths.js';
-import { run } from '../shared/run.js';
+import { capture, run } from '../shared/run.js';
 import { blank, bullets, heading, info, step, success, warn } from '../shared/ui.js';
 import { DEFAULT_FUNCTIONS_REGION, KERNEL_COMPONENTS, KERNEL_DISTRIBUTION_ID, MANUAL_PREREQUISITES, MINIMUM_CLI_VERSION, REQUIRED_NODE_VERSION, callableFunctionNames, declaredParametersIn, exportedFunctionNames, parseKernelVersion, parsePreLoginPoints, } from '../kernel/manifest.js';
 import { digestOfFile } from '../shared/digest.js';
@@ -111,6 +111,18 @@ const stageSdk = async (root, stageDir, version) => {
     info(`  ${examples.length} first-party extension(s) staged as source examples`);
     return { version, kernelVersion, path: `sdk/${SDK_TARBALL}` };
 };
+/**
+ * Lido ANTES do gate e dos builds: eles geram arquivos, e o que importa é o estado da árvore que o
+ * pacote vai refletir, não o que o próprio `pack` deixou nela. Fora de um checkout git não há commit a
+ * registrar, e isso não é motivo para recusar o pacote.
+ */
+const sourceOf = async (root) => {
+    const head = await capture('git', ['rev-parse', 'HEAD'], { cwd: root }).catch(() => null);
+    if (head === null || head.code !== 0)
+        return undefined;
+    const status = await capture('git', ['status', '--porcelain'], { cwd: root });
+    return { commit: head.stdout.trim(), dirty: status.code !== 0 || status.stdout.trim() !== '' };
+};
 export const pack = async (args) => {
     await assertInsideRepository('pack');
     const root = repoRoot;
@@ -145,6 +157,22 @@ export const pack = async (args) => {
     const stageDir = join(outputDir, 'package');
     const tarball = join(outputDir, kernelTarballName(version));
     heading(`Packaging Microteia kernel ${version} (contract ${kernelVersion})`);
+    const source = await sourceOf(root);
+    if (source === undefined) {
+        warn('Not a git checkout: the package will not say which commit it came from, and publishing will not tag one.');
+    }
+    else if (source.dirty) {
+        warn(`Uncommitted changes: the package is not commit ${source.commit.slice(0, 12)}, and publishing will not `
+            + 'tag the source repository. Commit first to have it tagged.');
+    }
+    else {
+        info(`  from commit ${source.commit.slice(0, 12)}`);
+        // Pelas referências remotas LOCAIS, sem rede: é só um lembrete. Quem cobra é o `publish`, contra o GitHub.
+        const remote = await capture('git', ['branch', '-r', '--contains', source.commit], { cwd: root });
+        if (remote.code === 0 && remote.stdout.trim() === '') {
+            warn(`Commit ${source.commit.slice(0, 12)} has not been pushed: "microteia publish" will refuse until it is.`);
+        }
+    }
     const total = 7;
     if (skipVerify) {
         info('Quality gate skipped (--skip-verify).');
@@ -201,6 +229,11 @@ export const pack = async (args) => {
     // O histórico do kernel viaja DENTRO do pacote, e é de lá que o `unpack` o copia para a raiz da
     // instalação. Escrito do conteúdo já conferido, para não ler o arquivo duas vezes.
     await writeFile(join(stageDir, KERNEL_CHANGELOG), changelog);
+    // A AGPL exige que o texto da licença acompanhe cada cópia distribuída do compilado, e o NOTICE
+    // carrega os termos da seção 7 — atribuição e exceção para extensões — que só valem se viajarem juntos.
+    for (const file of ['LICENSE', 'NOTICE']) {
+        await cp(join(root, file), join(stageDir, file));
+    }
     // O `firestore.indexes.json` do pacote é ESCRITO, não copiado: a raiz é o conjunto completo (é o que
     // roda em `microteia-dev` e `curatino`), e o que uma extensão reivindica sai daqui para ser criado
     // pelo `provision` quando ela for instalada. Os `fieldOverrides` são todos do kernel e vão inteiros.
@@ -219,6 +252,7 @@ export const pack = async (args) => {
         kernelVersion,
         minimumCliVersion: MINIMUM_CLI_VERSION,
         packagedAt: new Date().toISOString(),
+        source,
         components: KERNEL_COMPONENTS,
         requires: {
             functionsRegion: DEFAULT_FUNCTIONS_REGION,

package/lib/vendor/packConsole.js

@@ -48,6 +48,11 @@ export const packConsole = async (args) => {
     await writeFile(join(outputDir, 'package.json'), consolePackageJson(CLI_VERSION));
     await writeFile(join(outputDir, 'README.md'), consoleReadme(CLI_VERSION));
     await writeFile(join(outputDir, CONSOLE_CHANGELOG), changelog);
+    // A AGPL exige que o texto da licença acompanhe cada cópia distribuída — e esta é a que vai ao npm.
+    // O NOTICE carrega os termos da seção 7 (atribuição, exceção para extensões), que viajam junto.
+    for (const file of ['LICENSE', 'NOTICE']) {
+        await cp(join(repoRoot, file), join(outputDir, file));
+    }
     // Executável com o shebang que o entrypoint já tem: é o que permite apontar um link para ele em
     // qualquer diretório do PATH, sem npm e sem sudo. O `tsc` não carimba a permissão, e no repositório
     // ela vem do `npm install` (que a aplica no alvo do `bin`) — o que não existe numa pasta copiada.

package/lib/vendor/packageTemplates.js

@@ -166,10 +166,11 @@ export const consolePackageJson = (version) => JSON.stringify({
     name: CONSOLE_PACKAGE_NAME,
     version,
     description: 'Install and update Microteia in a Firebase project you own.',
-    license: 'UNLICENSED',
+    license: 'AGPL-3.0-or-later',
+    repository: { type: 'git', url: 'git+https://github.com/microteia/microteia.git' },
     type: 'module',
     bin: { microteia: 'lib/index.js' },
-    files: ['lib', 'README.md', 'CONSOLE-VERSIONS.md'],
+    files: ['lib', 'README.md', 'CONSOLE-VERSIONS.md', 'LICENSE', 'NOTICE'],
     engines: { node: '>=22' },
     publishConfig: { access: 'public' },
 }, null, 2) + '\n';
@@ -239,4 +240,11 @@ the Microteia repository.
 
 \`CONSOLE-VERSIONS.md\`, in this folder. \`unpack\` copies it into the installation it manages, beside the
 platform's own \`KERNEL-VERSIONS.md\` — each history travels with the artifact it describes.
+
+## License
+
+Free software, licensed under the GNU Affero General Public License, version 3 or (at your option) any
+later version — the full text is in \`LICENSE\`, and the additional terms in \`NOTICE\`, in this folder.
+The source code of this Console and of the platform it installs is at
+https://github.com/microteia/microteia.
 `;

package/lib/vendor/publish.js

@@ -161,6 +161,57 @@ const releaseExists = async (repo, version) => {
     const result = await capture('gh', ['release', 'view', tagOf(version), '--repo', repo]);
     return result.code === 0;
 };
+/** O que impede marcar o repositório-fonte, já dito em palavras; `null` quando dá para marcar. */
+const sourceReleaseBlocker = (manifest) => {
+    if (manifest.source === undefined) {
+        return 'its manifest does not say which commit it came from (packed before this was recorded, or outside git)';
+    }
+    if (manifest.source.dirty) {
+        return `it was packed with uncommitted changes, so commit ${manifest.source.commit.slice(0, 12)} is not its source`;
+    }
+    return null;
+};
+const sourceRepository = async (root) => (await captureOrThrow('gh', ['repo', 'view', '--json', 'nameWithOwner', '--jq', '.nameWithOwner'], { cwd: root }))
+    .trim();
+const sourceReleaseNotes = (releasesRepo, version, notes) => `Packaged from this commit. The installable artifacts are published in `
+    + `[${releasesRepo}](https://github.com/${releasesRepo}/releases/tag/${tagOf(version)}).\n\n${notes}`;
+/**
+ * O commit de origem tem de estar no GitHub ANTES de qualquer coisa subir. Conferido só no fim, ele
+ * deixava o kernel publicado e a tag por fazer à mão — e rodar o `publish` de novo não conserta,
+ * porque o catálogo já recusa a versão publicada. Recusado aqui, nada saiu, e o mesmo comando
+ * funciona depois do `git push`.
+ *
+ * Um 422 é o GitHub dizendo que não conhece o commit; qualquer outra falha é dita como é, para não
+ * mandar dar push quem tem um problema de rede ou de credencial.
+ */
+const assertSourcePushed = async (target, version) => {
+    const result = await capture('gh', ['api', `repos/${target.repo}/commits/${target.commit}`]);
+    if (result.code === 0)
+        return;
+    const detail = `${result.stderr}${result.stdout}`;
+    if (detail.includes('HTTP 422') || detail.includes('No commit found')) {
+        throw new Error(`Kernel ${version} was packed from commit ${target.commit.slice(0, 12)}, which is not on GitHub yet.\n`
+            + `Push it first ("git push"), then publish again — nothing was published.\n`
+            + `The tag ${tagOf(version)} goes on that commit in ${target.repo}, and GitHub cannot tag a commit it does not have.`);
+    }
+    throw new Error(`Could not check whether commit ${target.commit.slice(0, 12)} is on GitHub (${target.repo}).\n`
+        + `${result.stderr.trim() || result.stdout.trim()}`);
+};
+const createSourceRelease = async (target, version, notesFile, latest) => {
+    if (await releaseExists(target.repo, version)) {
+        info(`  ${tagOf(version)} already exists in ${target.repo}`);
+        return;
+    }
+    await captureOrThrow('gh', [
+        'release', 'create', tagOf(version),
+        '--repo', target.repo,
+        '--target', target.commit,
+        '--title', `Microteia kernel ${version}`,
+        '--notes-file', notesFile,
+        `--latest=${latest}`,
+    ]);
+    success(`${tagOf(version)} marks commit ${target.commit.slice(0, 12)} in ${target.repo}`);
+};
 /**
  * O pacote do kernel, conferido antes de qualquer coisa subir.
  *
@@ -221,6 +272,30 @@ const publishKernel = async (root, version, repo, dryRun) => {
     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'}`);
+    /**
+     * Pacote sem commit que o represente (antigo, ou montado com árvore suja) só avisa: recusar travaria a
+     * publicação por um registro que não tem como existir. Já o commit que existe e não subiu RECUSA — o
+     * conserto é um `git push`, e ele vem antes de qualquer coisa ir para o ar.
+     */
+    let source = null;
+    const blocker = sourceReleaseBlocker(manifest);
+    if (blocker !== null) {
+        warn(`the source repository will not be tagged: ${blocker}`);
+    }
+    else if (manifest.source !== undefined) {
+        const sourceRepo = await sourceRepository(root).catch(() => null);
+        if (sourceRepo === null) {
+            warn('the source repository will not be tagged: "gh repo view" could not name the repository of this checkout');
+        }
+        else if (sourceRepo === repo) {
+            warn(`the source repository will not be tagged: it is ${repo} itself, which already gets ${tagOf(version)}`);
+        }
+        else {
+            source = { repo: sourceRepo, commit: manifest.source.commit };
+            await assertSourcePushed(source, version);
+            info(`  and ${tagOf(version)} on commit ${source.commit.slice(0, 12)} in ${sourceRepo}, pointing here`);
+        }
+    }
     if (dryRun) {
         if (published.empty)
             info(`  ${repo} has no commits, so it would be seeded with a README first`);
@@ -280,6 +355,14 @@ const publishKernel = async (root, version, repo, dryRun) => {
                 .then(() => success(`${README_PATH} in ${repo} rewritten`))
                 .catch((error) => warn(`${README_PATH} in ${repo} could not be rewritten: ${error instanceof Error ? error.message : String(error)}`));
         }
+        // Pela mesma razão do README: depois do catálogo, e a falha só avisa.
+        if (source !== null) {
+            const target = source;
+            const sourceNotesFile = join(notesRoot, 'source-notes.md');
+            await writeFile(sourceNotesFile, sourceReleaseNotes(repo, version, notes.body));
+            await createSourceRelease(target, version, sourceNotesFile, promotes)
+                .catch((error) => warn(`${tagOf(version)} could not be created in ${target.repo}: ${error instanceof Error ? error.message : String(error)}`));
+        }
     }
     finally {
         await rm(notesRoot, { recursive: true, force: true });

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@microteia/console",
-  "version": "2.38.0",
+  "version": "2.42.0",
   "description": "Install and update Microteia in a Firebase project you own.",
-  "license": "UNLICENSED",
+  "license": "AGPL-3.0-or-later",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/microteia/microteia.git"
+  },
   "type": "module",
   "bin": {
     "microteia": "lib/index.js"
@@ -10,7 +14,9 @@
   "files": [
     "lib",
     "README.md",
-    "CONSOLE-VERSIONS.md"
+    "CONSOLE-VERSIONS.md",
+    "LICENSE",
+    "NOTICE"
   ],
   "engines": {
     "node": ">=22"