kaven-cli 0.3.0 → 0.4.0-alpha.1

package/dist/commands/init/index.js

@@ -170,6 +170,21 @@ async function initProject(projectName, options) {
             console.error(chalk_1.default.gray(error instanceof Error ? error.message : String(error)));
         }
     }
+    // Install kaven-squad (optional, non-fatal)
+    if (options.withSquad) {
+        const squadSpinner = (0, ora_1.default)("Installing kaven-squad...").start();
+        const squadResult = await initializer.installSquad(targetDir);
+        if (squadResult.installed) {
+            squadSpinner.succeed("kaven-squad installed in squads/kaven-squad/");
+        }
+        else if (squadResult.reason === "already-exists") {
+            squadSpinner.info("kaven-squad already installed — skipping");
+        }
+        else {
+            squadSpinner.warn(`Could not install kaven-squad automatically (${squadResult.reason})`);
+            console.log(chalk_1.default.yellow("  ⚠  Install manually inside the project: *download-squad kaven-squad"));
+        }
+    }
     // Health check
     const healthCheckSpinner = (0, ora_1.default)("Running health check...").start();
     const health = await initializer.healthCheck(targetDir);
@@ -193,6 +208,12 @@ async function initProject(projectName, options) {
     console.log(chalk_1.default.cyan("  pnpm dev"));
     console.log();
     console.log(chalk_1.default.gray("For more help, visit: https://docs.kaven.sh/getting-started"));
+    if (options.withSquad) {
+        console.log();
+        console.log(chalk_1.default.bold("AIOX Squad next step:"));
+        console.log(chalk_1.default.cyan("  node /path/to/aiox-core/bin/aiox.js install --quiet --merge"));
+        console.log(chalk_1.default.gray("  (replace /path/to/aiox-core with your AIOX installation path)"));
+    }
     // Save project defaults to config for future use
     await ConfigManager_1.configManager.initialize();
     try {

package/dist/commands/module/activate.js

@@ -0,0 +1,204 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moduleActivate = moduleActivate;
+exports.moduleDeactivate = moduleDeactivate;
+exports.moduleListActivation = moduleListActivation;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const SchemaActivator_1 = require("../../core/SchemaActivator");
+const TelemetryBuffer_1 = require("../../infrastructure/TelemetryBuffer");
+// ============================================================
+// Helpers
+// ============================================================
+function findModuleDef(moduleId) {
+    return SchemaActivator_1.KAVEN_MODULES.find((m) => m.id === moduleId.toLowerCase());
+}
+function assertSchemaExists(exists) {
+    if (!exists) {
+        console.error(chalk_1.default.red("\nNão encontrei packages/database/prisma/schema.extended.prisma."));
+        console.error(chalk_1.default.gray("Execute este comando na raiz de um projeto Kaven."));
+        process.exit(1);
+    }
+}
+// ============================================================
+// kaven module activate <name>
+// ============================================================
+async function moduleActivate(moduleName, projectRoot) {
+    const telemetry = TelemetryBuffer_1.TelemetryBuffer.getInstance();
+    const startTime = Date.now();
+    telemetry.capture("cli.module.activate.start", { moduleName });
+    const root = projectRoot ?? process.cwd();
+    const activator = new SchemaActivator_1.SchemaActivator(root);
+    const spinner = (0, ora_1.default)(`Ativando módulo ${moduleName}...`).start();
+    try {
+        // 1. Validar que o schema existe
+        const exists = await activator.exists();
+        spinner.stop();
+        assertSchemaExists(exists);
+        // 2. Validar que o módulo é conhecido
+        const def = findModuleDef(moduleName);
+        if (!def) {
+            console.error(chalk_1.default.red(`\nMódulo desconhecido: "${moduleName}".`));
+            console.error(chalk_1.default.gray(`Módulos disponíveis: ${SchemaActivator_1.KAVEN_MODULES.map((m) => m.id).join(", ")}`));
+            process.exit(1);
+        }
+        // 3. Verificar dependências
+        if (def.dependsOn.length > 0) {
+            spinner.start("Verificando dependências...");
+            const depStatuses = [];
+            for (const depId of def.dependsOn) {
+                const depDef = findModuleDef(depId);
+                if (!depDef)
+                    continue;
+                const status = await activator.getModuleStatus(depDef);
+                depStatuses.push(status);
+            }
+            const missing = depStatuses.filter((s) => !s.active);
+            if (missing.length > 0) {
+                spinner.stop();
+                console.error(chalk_1.default.red(`\nDependências inativas para "${moduleName}": ${missing.map((m) => m.id).join(", ")}`));
+                console.error(chalk_1.default.gray(`Ative as dependências primeiro:\n${missing.map((m) => `  kaven module activate ${m.id}`).join("\n")}`));
+                process.exit(1);
+            }
+            spinner.stop();
+        }
+        // 4. Verificar se já está ativo
+        const current = await activator.getModuleStatus(def);
+        if (current.active) {
+            console.log(chalk_1.default.yellow(`\nMódulo "${def.label}" já está ativo.`));
+            return;
+        }
+        // 5. Ativar
+        spinner.start(`Descomentando modelos de ${def.label} no schema...`);
+        await activator.activateModule(def);
+        spinner.succeed(chalk_1.default.green(`\nMódulo ${def.label} ativado. ${def.models.length} models adicionados: ${def.models.join(", ")}`));
+        console.log(chalk_1.default.cyan("\nSugestão: Execute `pnpm db:generate && pnpm db:migrate` para aplicar as mudanças."));
+        telemetry.capture("cli.module.activate.success", { moduleName: def.id, models: def.models.length }, Date.now() - startTime);
+        await telemetry.flush();
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red(`Falha ao ativar módulo: ${error instanceof Error ? error.message : String(error)}`));
+        telemetry.capture("cli.module.activate.error", { moduleName, error: error.message }, Date.now() - startTime);
+        await telemetry.flush();
+        process.exit(1);
+    }
+}
+// ============================================================
+// kaven module deactivate <name>
+// ============================================================
+async function moduleDeactivate(moduleName, projectRoot) {
+    const telemetry = TelemetryBuffer_1.TelemetryBuffer.getInstance();
+    const startTime = Date.now();
+    telemetry.capture("cli.module.deactivate.start", { moduleName });
+    const root = projectRoot ?? process.cwd();
+    const activator = new SchemaActivator_1.SchemaActivator(root);
+    const spinner = (0, ora_1.default)(`Desativando módulo ${moduleName}...`).start();
+    try {
+        // 1. Validar que o schema existe
+        const exists = await activator.exists();
+        spinner.stop();
+        assertSchemaExists(exists);
+        // 2. Validar módulo
+        const def = findModuleDef(moduleName);
+        if (!def) {
+            console.error(chalk_1.default.red(`\nMódulo desconhecido: "${moduleName}".`));
+            console.error(chalk_1.default.gray(`Módulos disponíveis: ${SchemaActivator_1.KAVEN_MODULES.map((m) => m.id).join(", ")}`));
+            process.exit(1);
+        }
+        // 3. Verificar se outros módulos ativos dependem deste
+        spinner.start("Verificando dependências reversas...");
+        const dependents = [];
+        for (const candidate of SchemaActivator_1.KAVEN_MODULES) {
+            if (candidate.id === def.id)
+                continue;
+            if (!candidate.dependsOn.includes(def.id))
+                continue;
+            const status = await activator.getModuleStatus(candidate);
+            if (status.active) {
+                dependents.push(candidate.id);
+            }
+        }
+        if (dependents.length > 0) {
+            spinner.stop();
+            console.error(chalk_1.default.red(`\nNão é possível desativar "${moduleName}": os seguintes módulos dependem dele e estão ativos:`));
+            console.error(chalk_1.default.gray(`  ${dependents.join(", ")}`));
+            console.error(chalk_1.default.gray(`Desative-os primeiro:\n${dependents.map((d) => `  kaven module deactivate ${d}`).join("\n")}`));
+            process.exit(1);
+        }
+        // 4. Verificar se já está inativo
+        const current = await activator.getModuleStatus(def);
+        if (!current.active) {
+            spinner.stop();
+            console.log(chalk_1.default.yellow(`\nMódulo "${def.label}" já está inativo.`));
+            return;
+        }
+        // 5. Desativar
+        spinner.start(`Comentando modelos de ${def.label} no schema...`);
+        await activator.deactivateModule(def);
+        spinner.succeed(chalk_1.default.green(`\nMódulo ${def.label} desativado com sucesso.`));
+        console.log(chalk_1.default.cyan("\nSugestão: Execute `pnpm db:generate && pnpm db:migrate` para aplicar as mudanças."));
+        telemetry.capture("cli.module.deactivate.success", { moduleName: def.id }, Date.now() - startTime);
+        await telemetry.flush();
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red(`Falha ao desativar módulo: ${error instanceof Error ? error.message : String(error)}`));
+        telemetry.capture("cli.module.deactivate.error", { moduleName, error: error.message }, Date.now() - startTime);
+        await telemetry.flush();
+        process.exit(1);
+    }
+}
+// ============================================================
+// kaven module list
+// ============================================================
+async function moduleListActivation(projectRoot) {
+    const root = projectRoot ?? process.cwd();
+    const activator = new SchemaActivator_1.SchemaActivator(root);
+    const schemaExists = await activator.exists();
+    // Cabeçalho da tabela
+    const COL = {
+        module: 14,
+        status: 10,
+        models: 44,
+        deps: 20,
+    };
+    const header = chalk_1.default.bold("Module".padEnd(COL.module)) +
+        chalk_1.default.bold("Status".padEnd(COL.status)) +
+        chalk_1.default.bold("Models".padEnd(COL.models)) +
+        chalk_1.default.bold("Depends on");
+    const divider = "─".repeat(COL.module + COL.status + COL.models + COL.deps);
+    console.log();
+    console.log(chalk_1.default.blue("Módulos Kaven disponíveis\n"));
+    console.log(header);
+    console.log(chalk_1.default.gray(divider));
+    if (!schemaExists) {
+        for (const def of SchemaActivator_1.KAVEN_MODULES) {
+            const modCol = def.id.padEnd(COL.module);
+            const statusCol = chalk_1.default.gray("unknown".padEnd(COL.status));
+            const modelsCol = def.models.join(", ").padEnd(COL.models);
+            const depsCol = def.dependsOn.length > 0 ? def.dependsOn.join(", ") : "—";
+            console.log(`${modCol}${statusCol}${modelsCol}${depsCol}`);
+        }
+        console.log();
+        console.log(chalk_1.default.yellow("Atenção: schema.extended.prisma não encontrado. Status não pode ser determinado."));
+        console.log(chalk_1.default.gray("Execute este comando na raiz de um projeto Kaven para ver o status real."));
+        return;
+    }
+    for (const def of SchemaActivator_1.KAVEN_MODULES) {
+        const status = await activator.getModuleStatus(def);
+        const modCol = def.id.padEnd(COL.module);
+        const statusText = status.active ? "active" : "inactive";
+        const statusColored = status.active
+            ? chalk_1.default.green(statusText.padEnd(COL.status))
+            : chalk_1.default.gray(statusText.padEnd(COL.status));
+        const modelsCol = def.models.join(", ").padEnd(COL.models);
+        const depsCol = def.dependsOn.length > 0 ? def.dependsOn.join(", ") : "—";
+        console.log(`${modCol}${statusColored}${modelsCol}${depsCol}`);
+    }
+    console.log();
+    console.log(chalk_1.default.gray("Core (sempre ativo): Tenant, User, Role, Capability, AuthSession, AuditLog"));
+    console.log();
+    console.log(chalk_1.default.gray("Para ativar: kaven module activate <name>  |  Para desativar: kaven module deactivate <name>"));
+}

package/dist/core/ModuleDoctor.js

@@ -28,9 +28,9 @@ class ModuleDoctor {
     async checkAnchors() {
         const results = [];
         const expectedAnchors = [
-            { file: "apps/api/src/index.ts", anchor: "// [ANCHOR:ROUTES]" },
-            { file: "apps/api/src/index.ts", anchor: "// [ANCHOR:MIDDLEWARE]" },
-            { file: "apps/admin/app/layout.tsx", anchor: "// [ANCHOR:NAV_ITEMS]" },
+            { file: "apps/api/src/app.ts", anchor: "// [KAVEN_MODULE_IMPORTS]" },
+            { file: "apps/api/src/app.ts", anchor: "// [KAVEN_MODULE_HOOKS]" },
+            { file: "apps/api/src/app.ts", anchor: "// [KAVEN_MODULE_REGISTRATION]" },
         ];
         for (const { file, anchor } of expectedAnchors) {
             const filePath = path_1.default.join(this.projectRoot, file);
@@ -433,7 +433,7 @@ class ModuleDoctor {
         return results;
     }
     async readKavenConfig() {
-        const configPath = path_1.default.join(this.projectRoot, "kaven.config.json");
+        const configPath = path_1.default.join(this.projectRoot, "kaven.json");
         if (!(await fs_extra_1.default.pathExists(configPath))) {
             return { modules: [] };
         }

package/dist/core/ProjectInitializer.js

@@ -8,6 +8,7 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const TEMPLATE_REPO = "https://github.com/kaven-co/kaven-template.git";
+const KAVEN_SQUAD_REPO = "https://github.com/bychrisr/kaven-squad";
 /** Run a shell command via spawn, returning exit code. */
 function runCommand(cmd, args, cwd, onData) {
     return new Promise((resolve, reject) => {
@@ -93,6 +94,33 @@ class ProjectInitializer {
         await runCommand("git", ["add", "."], targetDir);
         await runCommand("git", ["commit", "-m", "chore: initial kaven setup"], targetDir);
     }
+    /**
+     * Clone kaven-squad into squads/kaven-squad/ inside the project.
+     * Returns { installed: true } on success, { installed: false, reason } on failure.
+     * Never throws — squad installation is non-fatal.
+     */
+    async installSquad(targetDir) {
+        const squadsDir = path_1.default.join(targetDir, "squads");
+        const squadDir = path_1.default.join(squadsDir, "kaven-squad");
+        // Squad already present — skip
+        if (await fs_extra_1.default.pathExists(squadDir)) {
+            return { installed: false, reason: "already-exists" };
+        }
+        await fs_extra_1.default.ensureDir(squadsDir);
+        const exitCode = await runCommand("git", ["clone", "--depth", "1", KAVEN_SQUAD_REPO, squadDir], process.cwd());
+        if (exitCode !== 0) {
+            return {
+                installed: false,
+                reason: `git clone exited with code ${exitCode}`,
+            };
+        }
+        // Remove .git — squad history not needed in user project
+        const squadGitDir = path_1.default.join(squadDir, ".git");
+        if (await fs_extra_1.default.pathExists(squadGitDir)) {
+            await fs_extra_1.default.remove(squadGitDir);
+        }
+        return { installed: true };
+    }
     /** Health check after project initialization. */
     async healthCheck(targetDir) {
         const issues = [];

package/dist/core/SchemaActivator.js

@@ -0,0 +1,257 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaActivator = exports.KAVEN_MODULES = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+exports.KAVEN_MODULES = [
+    {
+        id: "billing",
+        label: "Billing",
+        description: "Faturamento, assinaturas e pagamentos",
+        models: ["Invoice", "Order", "Subscription", "Plan", "Payment", "Product"],
+        enums: [],
+        dependsOn: [],
+    },
+    {
+        id: "projects",
+        label: "Projects",
+        description: "Gestão de projetos e tasks",
+        models: ["Project", "Task"],
+        enums: ["ProjectStatus", "TaskStatus", "TaskPriority"],
+        dependsOn: [],
+    },
+    {
+        id: "notifications",
+        label: "Notifications",
+        description: "Notificações e preferências de usuário",
+        models: ["Notification", "UserPreference"],
+        enums: [],
+        dependsOn: [],
+    },
+];
+// ============================================================
+// Marcadores de seção no schema
+// ============================================================
+const BEGIN_MARKER = (moduleId) => `// [KAVEN_MODULE:${moduleId.toUpperCase()} BEGIN]`;
+const END_MARKER = (moduleId) => `// [KAVEN_MODULE:${moduleId.toUpperCase()} END]`;
+// ============================================================
+// SchemaActivator — lê/escreve schema.extended.prisma
+// ============================================================
+class SchemaActivator {
+    constructor(projectRoot) {
+        this.schemaPath = path_1.default.join(projectRoot, "packages", "database", "prisma", "schema.extended.prisma");
+    }
+    /** Verifica se o schema existe no projeto */
+    async exists() {
+        return fs_extra_1.default.pathExists(this.schemaPath);
+    }
+    /** Caminho absoluto do schema */
+    get path() {
+        return this.schemaPath;
+    }
+    /** Lê o conteúdo atual do schema */
+    async readSchema() {
+        return fs_extra_1.default.readFile(this.schemaPath, "utf-8");
+    }
+    /** Persiste o conteúdo no schema */
+    async writeSchema(content) {
+        await fs_extra_1.default.writeFile(this.schemaPath, content, "utf-8");
+    }
+    /**
+     * Detecta se um módulo está ativo no schema.
+     *
+     * Estratégia:
+     * 1. Se existirem marcadores BEGIN/END: verifica se o conteúdo dentro
+     *    dos marcadores NÃO está completamente comentado.
+     * 2. Se não houver marcadores: verifica se algum dos models principais
+     *    do módulo está presente e não comentado no arquivo.
+     */
+    async getModuleStatus(def) {
+        const content = await this.readSchema();
+        const begin = BEGIN_MARKER(def.id);
+        const end = END_MARKER(def.id);
+        const hasMarkers = content.includes(begin) && content.includes(end);
+        let active = false;
+        if (hasMarkers) {
+            const block = this.extractBlock(content, def.id);
+            active = block !== null && this.isBlockActive(block);
+        }
+        else {
+            // Sem marcadores: verifica presença de pelo menos um model descomentado
+            active = def.models.some((modelName) => this.isModelActive(content, modelName));
+        }
+        return {
+            id: def.id,
+            label: def.label,
+            description: def.description,
+            models: def.models,
+            dependsOn: def.dependsOn,
+            active,
+            hasMarkers,
+        };
+    }
+    /** Ativa um módulo: se tem marcadores, descomenta o bloco; senão, injeta o bloco */
+    async activateModule(def) {
+        const content = await this.readSchema();
+        const begin = BEGIN_MARKER(def.id);
+        const end = END_MARKER(def.id);
+        if (content.includes(begin) && content.includes(end)) {
+            const updated = this.uncommentBlock(content, def.id);
+            await this.writeSchema(updated);
+            return;
+        }
+        // Módulo não tem seção marcada — sem template para injetar
+        throw new Error(`O módulo "${def.id}" não possui uma seção marcada (BEGIN/END) no schema.\n` +
+            `Adicione o bloco do módulo manualmente com os marcadores:\n` +
+            `  ${begin}\n` +
+            `  ... models do módulo ...\n` +
+            `  ${end}`);
+    }
+    /** Desativa um módulo: comenta todos os models do bloco */
+    async deactivateModule(def) {
+        const content = await this.readSchema();
+        const begin = BEGIN_MARKER(def.id);
+        const end = END_MARKER(def.id);
+        if (!content.includes(begin) || !content.includes(end)) {
+            throw new Error(`O módulo "${def.id}" não possui marcadores BEGIN/END no schema. ` +
+                `Não é possível desativar automaticamente.`);
+        }
+        const updated = this.commentBlock(content, def.id);
+        await this.writeSchema(updated);
+    }
+    // ──────────────────────────────────────────────
+    // Helpers de manipulação de blocos
+    // ──────────────────────────────────────────────
+    /**
+     * Extrai o conteúdo entre os marcadores BEGIN e END (exclusive).
+     * Retorna null se os marcadores não forem encontrados.
+     */
+    extractBlock(content, moduleId) {
+        const begin = BEGIN_MARKER(moduleId);
+        const end = END_MARKER(moduleId);
+        const lines = content.split("\n");
+        let beginIdx = -1;
+        let endIdx = -1;
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].includes(begin))
+                beginIdx = i;
+            if (lines[i].includes(end) && beginIdx !== -1) {
+                endIdx = i;
+                break;
+            }
+        }
+        if (beginIdx === -1 || endIdx === -1)
+            return null;
+        return lines.slice(beginIdx + 1, endIdx).join("\n");
+    }
+    /**
+     * Verifica se um bloco tem ao menos uma linha não-comentada relevante
+     * (ignora linhas vazias e comentários simples).
+     */
+    isBlockActive(block) {
+        return block.split("\n").some((line) => {
+            const trimmed = line.trim();
+            return (trimmed.length > 0 &&
+                !trimmed.startsWith("//") &&
+                !trimmed.startsWith("/*") &&
+                !trimmed.startsWith("*"));
+        });
+    }
+    /**
+     * Verifica se um model específico está ativo (não comentado) no schema.
+     * Procura pela linha `model ModelName {` sem `//` antes.
+     */
+    isModelActive(content, modelName) {
+        const lines = content.split("\n");
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith(`model ${modelName}`) &&
+                !line.trimStart().startsWith("//")) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Comenta todas as linhas não-comentadas dentro do bloco BEGIN/END.
+     */
+    commentBlock(content, moduleId) {
+        const begin = BEGIN_MARKER(moduleId);
+        const end = END_MARKER(moduleId);
+        const lines = content.split("\n");
+        let inBlock = false;
+        const result = [];
+        for (const line of lines) {
+            if (line.includes(begin)) {
+                inBlock = true;
+                result.push(line);
+                continue;
+            }
+            if (line.includes(end)) {
+                inBlock = false;
+                result.push(line);
+                continue;
+            }
+            if (inBlock) {
+                const trimmed = line.trim();
+                if (trimmed.length === 0) {
+                    result.push(line);
+                }
+                else if (trimmed.startsWith("//")) {
+                    result.push(line); // já comentado
+                }
+                else {
+                    result.push(`// ${line}`);
+                }
+            }
+            else {
+                result.push(line);
+            }
+        }
+        return result.join("\n");
+    }
+    /**
+     * Remove `// ` do início das linhas dentro do bloco BEGIN/END.
+     */
+    uncommentBlock(content, moduleId) {
+        const begin = BEGIN_MARKER(moduleId);
+        const end = END_MARKER(moduleId);
+        const lines = content.split("\n");
+        let inBlock = false;
+        const result = [];
+        for (const line of lines) {
+            if (line.includes(begin)) {
+                inBlock = true;
+                result.push(line);
+                continue;
+            }
+            if (line.includes(end)) {
+                inBlock = false;
+                result.push(line);
+                continue;
+            }
+            if (inBlock) {
+                // Remove exatamente um nível de comentário `// ` ou `//`
+                if (line.trimStart().startsWith("// ")) {
+                    const indent = line.length - line.trimStart().length;
+                    result.push(line.slice(0, indent) + line.trimStart().slice(3));
+                }
+                else if (line.trimStart().startsWith("//")) {
+                    const indent = line.length - line.trimStart().length;
+                    result.push(line.slice(0, indent) + line.trimStart().slice(2));
+                }
+                else {
+                    result.push(line);
+                }
+            }
+            else {
+                result.push(line);
+            }
+        }
+        return result.join("\n");
+    }
+}
+exports.SchemaActivator = SchemaActivator;

package/dist/core/SignatureVerifier.js

@@ -33,9 +33,8 @@ function decodeSignature(encoded) {
  * Verify Ed25519 signature against a SHA-256 checksum.
  *
  * Accepts signature in either hex or base64 encoding.
- * The publisher signs the hex-encoded checksum with their
- * Ed25519 private key. We verify using the public key stored
- * in the release metadata.
+ * Tolerates signatures made over checksum with trailing newline
+ * (common when signing via `echo checksum > file && openssl sign`).
  */
 function verifyEd25519Signature(checksum, signature, publicKeyBase64) {
     try {
@@ -45,7 +44,11 @@ function verifyEd25519Signature(checksum, signature, publicKeyBase64) {
             format: "der",
         });
         const sigBuffer = decodeSignature(signature);
-        return crypto_1.default.verify(null, Buffer.from(checksum), publicKey, sigBuffer);
+        if (crypto_1.default.verify(null, Buffer.from(checksum), publicKey, sigBuffer)) {
+            return true;
+        }
+        // Tolerate trailing newline from shell-based signing
+        return crypto_1.default.verify(null, Buffer.from(checksum + "\n"), publicKey, sigBuffer);
     }
     catch {
         return false;