@pasosdejesus/mpdj 0.1.0

package/dist/tasks/credentials.js

@@ -0,0 +1,627 @@
+// src/tasks/credentials.ts
+// CLI commands for PasosDeJesusCredentials administration.
+//
+// Commands:
+//   m credentials:list-types       --network <net>
+//   m credentials:mint             --network <net> --token-id <id> --address <wallet> [--amount <n>]
+//   m credentials:register-type    --network <net> --site <name> --type <name> --display <name>
+//                                  --soulbound <true|false> [--course-id <id>] [--premium]
+//                                  [--custom-uri <uri>] [--max-supply <n>]
+//                                  [--icon public/img/credential/source/myicon.svg]
+//   m credentials:recompose-image  --token-id <id> --network <net> --icon <path>
+//   m credentials:set-max-supply   --network <net> --token-id <id> --max <n>
+//   m credentials:set-site-uri     --network <net> --site <name> --uri <url>
+//   m credentials:sync-cache       --network <net>
+//   m credentials:grant-minter     --network <net> --address <wallet>
+//   m credentials:revoke-minter    --network <net> --address <wallet>
+//   m credentials:revoke-credential --network <net> --token-id <id> --address <wallet> [--amount <n>]
+//
+// Conditional visibility:
+//   - If apps/hardhat/deployments/PasosDeJesusCredentials/ exists → credentials:* appears in CLI
+//   - If CREDENTIALS_PRIVATE_KEY is set → admin commands (grant-minter, revoke-minter) available
+import * as fs from 'fs';
+import * as path from 'path';
+import { createRequire } from 'module';
+import { problem } from '@pasosdejesus/m/dist/util/colors.js';
+import { createTranslator } from '@pasosdejesus/m/dist/i18n/createTranslator.js';
+import { detectLocale } from '@pasosdejesus/m/dist/util/locale.js';
+import commonCli from '@pasosdejesus/m/dist/i18n/common-cli.js';
+const require = createRequire(import.meta.url);
+const locale = detectLocale();
+const ct = createTranslator(locale, {
+    en: {
+        'cred.usage_header': 'Usage: m credentials:<command> [args]',
+        'cred.usage_commands': 'Commands:',
+        'cred.usage_list_types': 'list-types       --network <net>',
+        'cred.usage_mint': 'mint             --network <net> --token-id <id> --address <wallet> [--amount <n>]',
+        'cred.usage_register': 'register-type    --network <net> --site <name> --type <name> --display <name>',
+        'cred.usage_register_opts': '                 --soulbound <true|false> [--course-id <id>] [--premium]',
+        'cred.usage_register_icon': '                 [--icon public/img/credential/source/myicon.svg]',
+        'cred.usage_recompose': 'recompose-image  --token-id <id> --network <net> --icon <path>',
+        'cred.usage_set_max': 'set-max-supply   --network <net> --token-id <id> --max <n>',
+        'cred.usage_set_uri': 'set-site-uri     --network <net> --site <name> --uri <url>',
+        'cred.usage_sync': 'sync-cache       --network <net>',
+        'cred.usage_grant': 'grant-minter     --network <net> --address <wallet>',
+        'cred.usage_revoke_minter': 'revoke-minter    --network <net> --address <wallet>',
+        'cred.usage_revoke': 'revoke-credential --network <net> --token-id <id> --address <wallet> [--amount <n>]',
+        'cred.usage_networks': 'Networks: celo, celoSepolia, base, baseSepolia',
+        'cred.unknown_command': 'Unknown command: {{0}}',
+        'cred.no_admin_key': 'CREDENTIALS_PRIVATE_KEY required for admin commands',
+        'cred.key_missing': 'PRIVATE_KEY not set',
+        'cred.key_or_admin_missing': 'CREDENTIALS_PRIVATE_KEY not set in .env',
+        'cred.no_privkey': 'PRIVATE_KEY not set',
+        'cred.emission_failed': 'Emission tracking failed: {{0}}',
+        'cred.minted': 'Minted token {{0}} x{{1}} to {{2}} on {{3}}. TX: {{4}}',
+        'cred.types_header': 'Credential types on {{0}} (nextTokenId: {{1}}):',
+        'cred.type_row': '  {{0}}: {{1}} (soulbound: {{2}}, maxSupply: {{3}})',
+        'cred.register_success': 'Credential type registered. tokenId: {{0}} site: {{1}} type: {{2}} name: {{3}}',
+        'cred.cache_failed': 'Cache update failed: {{0}}',
+        'cred.image_failed': 'Image composition failed (tokenId {{0}}): {{1}}',
+        'cred.recompose_title': 'Image recomposed for token {{0}} ({{1}})',
+        'cred.recompose_svg': '  SVG: {{0}}',
+        'cred.recompose_png': '  PNG: {{0}}',
+        'cred.token_not_in_cache': 'Token {{0}} not found in credential_metadata cache. Register first with register-type.',
+        'cred.max_set': 'maxSupply set. tokenId: {{0}} max: {{1}} TX: {{2}}',
+        'cred.uri_set': 'siteBaseURI set. site: {{0}} uri: {{1}} TX: {{2}}',
+        'cred.granted': 'MINTER_ROLE granted to {{0}} on {{1}}. TX: {{2}}',
+        'cred.revoked_minter': 'MINTER_ROLE revoked from {{0}} on {{1}}. TX: {{2}}',
+        'cred.revoked': 'Revoked token {{0}} x{{1}} from {{2}} on {{3}}. TX: {{4}}',
+        'cred.sync_row': '  Cached token {{0}}: {{1}}',
+        'cred.sync_done': 'Sync complete. {{0}} tokens cached on {{1}}.',
+        'cred.deploy_not_found': 'No deployment found for {{0}}. Deploy first or set {{1}} in .env',
+        'cred.unknown_network': 'Unknown network: {{0}}',
+        'cred.args_missing_mint': '--network, --token-id, --address required',
+        'cred.args_missing_register': '--network, --site, --type, --display required',
+        'cred.args_missing_recompose': '--token-id and --icon required',
+        'cred.args_missing_max': '--network, --token-id, --max required',
+        'cred.args_missing_uri': '--network, --site, --uri required',
+        'cred.args_missing_grant': '--network and --address required',
+        'cred.args_missing_revoke': '--network, --token-id, --address required',
+    },
+    es: {
+        'cred.usage_header': 'Uso: m credentials:<orden> [args]',
+        'cred.usage_commands': 'Órdenes:',
+        'cred.usage_list_types': 'list-types       --network <red>',
+        'cred.usage_mint': 'mint             --network <red> --token-id <id> --address <billetera> [--amount <n>]',
+        'cred.usage_register': 'register-type    --network <red> --site <nombre> --type <nombre> --display <nombre>',
+        'cred.usage_register_opts': '                 --soulbound <true|false> [--course-id <id>] [--premium]',
+        'cred.usage_register_icon': '                 [--icon public/img/credential/source/miicono.svg]',
+        'cred.usage_recompose': 'recompose-image  --token-id <id> --network <red> --icon <ruta>',
+        'cred.usage_set_max': 'set-max-supply   --network <red> --token-id <id> --max <n>',
+        'cred.usage_set_uri': 'set-site-uri     --network <red> --site <nombre> --uri <url>',
+        'cred.usage_sync': 'sync-cache       --network <red>',
+        'cred.usage_grant': 'grant-minter     --network <red> --address <billetera>',
+        'cred.usage_revoke_minter': 'revoke-minter    --network <red> --address <billetera>',
+        'cred.usage_revoke': 'revoke-credential --network <red> --token-id <id> --address <billetera> [--amount <n>]',
+        'cred.usage_networks': 'Redes: celo, celoSepolia, base, baseSepolia',
+        'cred.unknown_command': 'Orden desconocida: {{0}}',
+        'cred.no_admin_key': 'Se requiere CREDENTIALS_PRIVATE_KEY para órdenes administrativas',
+        'cred.key_missing': 'PRIVATE_KEY no configurada',
+        'cred.key_or_admin_missing': 'CREDENTIALS_PRIVATE_KEY no configurada en .env',
+        'cred.no_privkey': 'PRIVATE_KEY no configurada',
+        'cred.emission_failed': 'Fallo en seguimiento de emisión: {{0}}',
+        'cred.minted': 'Acuñado token {{0}} x{{1}} a {{2}} en {{3}}. TX: {{4}}',
+        'cred.types_header': 'Tipos de credencial en {{0}} (nextTokenId: {{1}}):',
+        'cred.type_row': '  {{0}}: {{1}} (soulbound: {{2}}, maxSupply: {{3}})',
+        'cred.register_success': 'Tipo de credencial registrado. tokenId: {{0}} sitio: {{1}} tipo: {{2}} nombre: {{3}}',
+        'cred.cache_failed': 'Fallo al actualizar caché: {{0}}',
+        'cred.image_failed': 'Fallo en composición de imagen (tokenId {{0}}): {{1}}',
+        'cred.recompose_title': 'Imagen recompuesta para token {{0}} ({{1}})',
+        'cred.recompose_svg': '  SVG: {{0}}',
+        'cred.recompose_png': '  PNG: {{0}}',
+        'cred.token_not_in_cache': 'Token {{0}} no encontrado en caché credential_metadata. Regístrelo primero con register-type.',
+        'cred.max_set': 'maxSupply establecido. tokenId: {{0}} max: {{1}} TX: {{2}}',
+        'cred.uri_set': 'siteBaseURI establecido. sitio: {{0}} uri: {{1}} TX: {{2}}',
+        'cred.granted': 'MINTER_ROLE otorgado a {{0}} en {{1}}. TX: {{2}}',
+        'cred.revoked_minter': 'MINTER_ROLE revocado de {{0}} en {{1}}. TX: {{2}}',
+        'cred.revoked': 'Token {{0}} x{{1}} revocado de {{2}} en {{3}}. TX: {{4}}',
+        'cred.sync_row': '  Token {{0}} en caché: {{1}}',
+        'cred.sync_done': 'Sincronización completa. {{0}} tokens en caché en {{1}}.',
+        'cred.deploy_not_found': 'No se encontró despliegue para {{0}}. Despliegue primero o configure {{1}} en .env',
+        'cred.unknown_network': 'Red desconocida: {{0}}',
+        'cred.args_missing_mint': '--network, --token-id, --address requeridos',
+        'cred.args_missing_register': '--network, --site, --type, --display requeridos',
+        'cred.args_missing_recompose': '--token-id e --icon requeridos',
+        'cred.args_missing_max': '--network, --token-id, --max requeridos',
+        'cred.args_missing_uri': '--network, --site, --uri requeridos',
+        'cred.args_missing_grant': '--network y --address requeridos',
+        'cred.args_missing_revoke': '--network, --token-id, --address requeridos',
+    },
+}, commonCli);
+function getArg(args, name) {
+    const idx = args.indexOf(name);
+    return idx >= 0 && idx + 1 < args.length ? args[idx + 1] : null;
+}
+function hasFlag(args, name) {
+    return args.includes(name);
+}
+function getDeploymentsDir() {
+    const cwd = process.cwd();
+    const candidates = [
+        path.join(cwd, 'apps', 'hardhat', 'deployments', 'PasosDeJesusCredentials'),
+        path.join(cwd, '..', 'hardhat', 'deployments', 'PasosDeJesusCredentials'),
+        path.join(cwd, '..', '..', 'hardhat', 'deployments', 'PasosDeJesusCredentials'),
+    ];
+    for (const dir of candidates) {
+        if (fs.existsSync(dir))
+            return dir;
+    }
+    return candidates[0];
+}
+function getContractAddressFile(network) {
+    return path.join(getDeploymentsDir(), `${network}.json`);
+}
+function resolveAddress(network) {
+    const file = getContractAddressFile(network);
+    if (fs.existsSync(file)) {
+        return JSON.parse(fs.readFileSync(file, 'utf-8')).address;
+    }
+    const envKey = network.startsWith('base') ? 'NEXT_PUBLIC_PDJCREDENTIALS_BASE_ADDRESS' : 'NEXT_PUBLIC_PDJCREDENTIALS_CELO_ADDRESS';
+    const addr = process.env[envKey];
+    if (!addr)
+        throw new Error(ct('cred.deploy_not_found', network, envKey));
+    return addr;
+}
+async function getChain(network) {
+    const { celo, celoSepolia, base, baseSepolia } = await import('viem/chains');
+    switch (network) {
+        case 'celo': return celo;
+        case 'celoSepolia': return celoSepolia;
+        case 'base': return base;
+        case 'baseSepolia': return baseSepolia;
+        default: throw new Error(ct('cred.unknown_network', network));
+    }
+}
+async function getWalletClient(network, asAdmin) {
+    const { createWalletClient, http } = await import('viem');
+    const { privateKeyToAccount } = await import('viem/accounts');
+    const key = asAdmin
+        ? (process.env.CREDENTIALS_PRIVATE_KEY || process.env.PRIVATE_KEY)
+        : (process.env.PRIVATE_KEY || process.env.CREDENTIALS_PRIVATE_KEY);
+    if (!key)
+        throw new Error(ct('cred.key_or_admin_missing'));
+    const account = privateKeyToAccount(key);
+    return createWalletClient({ chain: await getChain(network), transport: http(), account });
+}
+async function getPublicClient(network) {
+    const { createPublicClient, http } = await import('viem');
+    return createPublicClient({ chain: await getChain(network), transport: http() });
+}
+async function newDb() {
+    const { Kysely, PostgresDialect } = await import('kysely');
+    const { Pool } = require('pg');
+    return new Kysely({
+        dialect: new PostgresDialect({
+            pool: new Pool({
+                host: process.env.PGHOST,
+                database: process.env.PGDATABASE,
+                user: process.env.PGUSER,
+                password: process.env.PGPASSWORD,
+                port: 5432,
+            }),
+        }),
+    });
+}
+function usage() {
+    console.log(ct('cred.usage_header'));
+    console.log('');
+    console.log(ct('cred.usage_commands'));
+    console.log('  ' + ct('cred.usage_list_types'));
+    console.log('  ' + ct('cred.usage_mint'));
+    console.log('  ' + ct('cred.usage_register'));
+    console.log('  ' + ct('cred.usage_register_opts'));
+    console.log('  ' + ct('cred.usage_register_icon'));
+    console.log('  ' + ct('cred.usage_recompose'));
+    console.log('  ' + ct('cred.usage_set_max'));
+    console.log('  ' + ct('cred.usage_set_uri'));
+    console.log('  ' + ct('cred.usage_sync'));
+    console.log('  ' + ct('cred.usage_grant'));
+    console.log('  ' + ct('cred.usage_revoke_minter'));
+    console.log('  ' + ct('cred.usage_revoke'));
+    console.log('');
+    console.log(ct('cred.usage_networks'));
+}
+async function listTypes(network) {
+    const pc = await getPublicClient(network);
+    const addr = resolveAddress(network);
+    const { default: credentialsAbi } = await import('../abis/PasosDeJesusCredentials.json', { with: { type: 'json' } });
+    const nextId = await pc.readContract({ address: addr, abi: credentialsAbi, functionName: 'nextTokenId' });
+    console.log(ct('cred.types_header', network, String(nextId)));
+    for (let i = 1; i < Number(nextId); i++) {
+        try {
+            const name = await pc.readContract({ address: addr, abi: credentialsAbi, functionName: 'tokenNames', args: [BigInt(i)] });
+            const sb = await pc.readContract({ address: addr, abi: credentialsAbi, functionName: 'isSoulbound', args: [BigInt(i)] });
+            const max = await pc.readContract({ address: addr, abi: credentialsAbi, functionName: 'maxSupply', args: [BigInt(i)] });
+            console.log(ct('cred.type_row', String(i), String(name), String(sb), String(max)));
+        }
+        catch { /* skip unconfigured */ }
+    }
+}
+async function mint(args) {
+    const net = getArg(args, '--network');
+    const tokenId = parseInt(getArg(args, '--token-id') || '');
+    const addr = getArg(args, '--address');
+    const amount = parseInt(getArg(args, '--amount') || '1');
+    if (!net || isNaN(tokenId) || !addr)
+        throw new Error(ct('cred.args_missing_mint'));
+    const key = process.env.PRIVATE_KEY;
+    if (!key)
+        throw new Error(ct('cred.no_privkey'));
+    const { createWalletClient, http } = await import('viem');
+    const { privateKeyToAccount } = await import('viem/accounts');
+    const { default: credentialsAbi } = await import('../abis/PasosDeJesusCredentials.json', { with: { type: 'json' } });
+    const account = privateKeyToAccount(key);
+    const wc = createWalletClient({ chain: await getChain(net), transport: http(), account });
+    const hash = await wc.writeContract({
+        address: resolveAddress(net),
+        abi: credentialsAbi,
+        functionName: 'mintCredential',
+        args: [addr, BigInt(tokenId), BigInt(amount)],
+        chain: wc.chain,
+        account: wc.account,
+    });
+    try {
+        const db = await newDb();
+        await db
+            .insertInto('credential_emission')
+            .values({ wallet_address: addr, token_id: tokenId, chain_id: net.includes('base') ? 'base' : 'celo' })
+            .onConflict((oc) => oc.columns(['wallet_address', 'token_id', 'chain_id']).doNothing())
+            .execute();
+    }
+    catch (e) {
+        console.warn(ct('cred.emission_failed', e.message));
+    }
+    console.log(ct('cred.minted', String(tokenId), String(amount), addr, net, hash));
+}
+async function registerType(args) {
+    const net = getArg(args, '--network');
+    const site = getArg(args, '--site');
+    const type = getArg(args, '--type');
+    const display = getArg(args, '--display');
+    const sb = getArg(args, '--soulbound') === 'true';
+    const courseId = parseInt(getArg(args, '--course-id') || '0');
+    const premium = hasFlag(args, '--premium');
+    const customURI = getArg(args, '--custom-uri') || '';
+    const maxSupply_ = parseInt(getArg(args, '--max-supply') || '0');
+    const icon = getArg(args, '--icon');
+    if (!net || !site || !type || !display)
+        throw new Error(ct('cred.args_missing_register'));
+    // registerCredentialType now uses MINTER_ROLE (backends can register)
+    const wc = await getWalletClient(net, false);
+    const pc = await getPublicClient(net);
+    const addr = resolveAddress(net);
+    const { default: credentialsAbi } = await import('../abis/PasosDeJesusCredentials.json', { with: { type: 'json' } });
+    const hash = await wc.writeContract({
+        address: addr,
+        abi: credentialsAbi,
+        functionName: 'registerCredentialType',
+        args: [site, type, display, sb, BigInt(courseId), premium, customURI, BigInt(maxSupply_)],
+        chain: wc.chain,
+        account: wc.account,
+    });
+    const receipt = await pc.waitForTransactionReceipt({ hash });
+    let tokenId = 0;
+    for (const log of receipt.logs) {
+        try {
+            const topics = log.topics;
+            if (topics && topics.length >= 2) {
+                tokenId = Number(BigInt(topics[1]));
+                break;
+            }
+        }
+        catch { }
+    }
+    if (tokenId === 0) {
+        const nextId = await pc.readContract({ address: addr, abi: credentialsAbi, functionName: 'nextTokenId' });
+        tokenId = Number(nextId) - 1;
+    }
+    if (icon) {
+        try {
+            const { composeCredentialImage } = await import('../blockchain/credential-images.js');
+            await composeCredentialImage({
+                userSvgPath: icon,
+                tokenId,
+                site,
+                siteName: site,
+                type,
+                isSoulbound: sb,
+                isPremium: premium,
+                displayName: display,
+                publicDir: path.join(process.cwd(), 'public'),
+                pngCommand: 'rsvg-convert -w 512 -h 512 -o',
+            });
+        }
+        catch (err) {
+            console.warn(ct('cred.image_failed', String(tokenId), err.message));
+        }
+    }
+    try {
+        const db = await newDb();
+        await db
+            .insertInto('credential_metadata')
+            .values({
+            token_id: tokenId,
+            name: display,
+            type,
+            site,
+            is_premium: premium,
+            is_soulbound: sb,
+            image_url: `img/credential/${tokenId}.png`,
+            chain_id: net,
+        })
+            .onConflict((oc) => oc.columns(['token_id', 'chain_id']).doUpdateSet({
+            name: display, type, site,
+            is_premium: premium, is_soulbound: sb,
+            updated_at: new Date(),
+        }))
+            .execute();
+    }
+    catch (err) {
+        console.warn(ct('cred.cache_failed', err.message));
+    }
+    console.log(ct('cred.register_success', String(tokenId), site, type, display));
+}
+async function recomposeImage(args) {
+    const tokenId = parseInt(getArg(args, '--token-id') || '');
+    const net = getArg(args, '--network') || 'celo';
+    const icon = getArg(args, '--icon');
+    if (isNaN(tokenId) || !icon)
+        throw new Error(ct('cred.args_missing_recompose'));
+    const chainId = net;
+    const db = await newDb();
+    const row = await db
+        .selectFrom('credential_metadata')
+        .selectAll()
+        .where('token_id', '=', tokenId)
+        .where('chain_id', '=', chainId)
+        .executeTakeFirst();
+    if (!row)
+        throw new Error(ct('cred.token_not_in_cache', String(tokenId)));
+    const { composeCredentialImage } = await import('../blockchain/credential-images.js');
+    const { svgPath, pngPath } = await composeCredentialImage({
+        userSvgPath: icon,
+        tokenId,
+        site: row.site,
+        siteName: row.site,
+        type: row.type,
+        isSoulbound: row.is_soulbound ?? true,
+        isPremium: row.is_premium,
+        displayName: row.name,
+        publicDir: path.join(process.cwd(), 'public'),
+        pngCommand: 'rsvg-convert -w 512 -h 512 -o',
+    });
+    console.log(ct('cred.recompose_title', String(tokenId), String(row.name)));
+    console.log(ct('cred.recompose_svg', svgPath));
+    console.log(ct('cred.recompose_png', pngPath));
+}
+async function setMaxSupply(args) {
+    const net = getArg(args, '--network');
+    const tokenId = parseInt(getArg(args, '--token-id') || '');
+    const max = parseInt(getArg(args, '--max') || '');
+    if (!net || isNaN(tokenId) || isNaN(max))
+        throw new Error(ct('cred.args_missing_max'));
+    const wc = await getWalletClient(net, true);
+    const hash = await wc.writeContract({
+        address: resolveAddress(net),
+        abi: (await import('../abis/PasosDeJesusCredentials.json', { with: { type: 'json' } })).default,
+        functionName: 'setMaxSupply',
+        args: [BigInt(tokenId), BigInt(max)],
+        chain: wc.chain,
+        account: wc.account,
+    });
+    console.log(ct('cred.max_set', String(tokenId), String(max), hash));
+}
+async function setSiteUri(args) {
+    const net = getArg(args, '--network');
+    const site = getArg(args, '--site');
+    const uri = getArg(args, '--uri');
+    if (!net || !site || !uri)
+        throw new Error(ct('cred.args_missing_uri'));
+    const wc = await getWalletClient(net, true);
+    const hash = await wc.writeContract({
+        address: resolveAddress(net),
+        abi: (await import('../abis/PasosDeJesusCredentials.json', { with: { type: 'json' } })).default,
+        functionName: 'setSiteBaseURI',
+        args: [site, uri],
+        chain: wc.chain,
+        account: wc.account,
+    });
+    console.log(ct('cred.uri_set', site, uri, hash));
+}
+async function syncCache(network) {
+    const pc = await getPublicClient(network);
+    const addr = resolveAddress(network);
+    const db = await newDb();
+    const { default: credentialsAbi } = await import('../abis/PasosDeJesusCredentials.json', { with: { type: 'json' } });
+    const siteMap = {
+        '0x616d78ebe5052eab0de25afa2c90b2cd8e550c70dfa0859ede7a9902335187ba': 'learn.tg',
+        '0x2eb33b8b6fa0a4cfa9282cd213f79e291a0a473487dd04b15bc4c9f11bffc6d9': 'sivel.xyz',
+        '0xc881844ff5e225c937d57807a73752d627e798112994cb398c38727eb732e580': 'stable-sl.pdJ.app',
+    };
+    const typeMap = {
+        '0x65a58990984f61f252fd6868ac0e9acb3befaf5d04a573bd155fc6c2e4159d9c': 'course_completion',
+        '0xa0a8be0a778a94eac2488e69eb5cf6921d2c02275d181a1189a6745aa6626f87': 'role',
+        '0x7a4833216f98c32023a615acdd8ead93c40086e7f9ba61c1d0d47dc1e8f0f174': 'achievement',
+        '0x7dd481eb4b63b94bb55e6b98aabb06c3b8484f82a4d656d6bca0b0cf9b446be0': 'nft',
+    };
+    let count = 0;
+    const nextId = await pc.readContract({ address: addr, abi: credentialsAbi, functionName: 'nextTokenId' });
+    for (let i = 1; i < Number(nextId); i++) {
+        try {
+            const [name, sb, premium, siteHash, typeHash] = await Promise.all([
+                pc.readContract({ address: addr, abi: credentialsAbi, functionName: 'tokenNames', args: [BigInt(i)] }),
+                pc.readContract({ address: addr, abi: credentialsAbi, functionName: 'isSoulbound', args: [BigInt(i)] }),
+                pc.readContract({ address: addr, abi: credentialsAbi, functionName: 'isPremiumCourse', args: [BigInt(i)] }),
+                pc.readContract({ address: addr, abi: credentialsAbi, functionName: 'tokenSiteHash', args: [BigInt(i)] }),
+                pc.readContract({ address: addr, abi: credentialsAbi, functionName: 'tokenTypeHash', args: [BigInt(i)] }),
+            ]);
+            if (!name || name === '')
+                continue;
+            const site = siteMap[siteHash] || 'unknown';
+            const type = typeMap[typeHash] || 'unknown';
+            await db
+                .insertInto('credential_metadata')
+                .values({
+                token_id: i, name: name, type, site,
+                is_premium: premium, is_soulbound: sb,
+                image_url: `img/credential/${i}.png`,
+                chain_id: network,
+            })
+                .onConflict((oc) => oc.columns(['token_id', 'chain_id']).doUpdateSet({
+                name: name, type, site,
+                is_soulbound: sb, is_premium: premium,
+                updated_at: new Date(),
+            }))
+                .execute();
+            count++;
+            console.log(ct('cred.sync_row', String(i), String(name)));
+        }
+        catch { /* skip */ }
+    }
+    console.log(ct('cred.sync_done', String(count), network));
+}
+async function grantMinter(args) {
+    const net = getArg(args, '--network');
+    const addr = getArg(args, '--address');
+    if (!net || !addr)
+        throw new Error(ct('cred.args_missing_grant'));
+    const wc = await getWalletClient(net, true);
+    const hash = await wc.writeContract({
+        address: resolveAddress(net),
+        abi: (await import('../abis/PasosDeJesusCredentials.json', { with: { type: 'json' } })).default,
+        functionName: 'grantRole',
+        args: ['0x9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a6', addr],
+        chain: wc.chain,
+        account: wc.account,
+    });
+    console.log(ct('cred.granted', addr, net, hash));
+}
+async function revokeMinter(args) {
+    const net = getArg(args, '--network');
+    const addr = getArg(args, '--address');
+    if (!net || !addr)
+        throw new Error(ct('cred.args_missing_grant'));
+    const wc = await getWalletClient(net, true);
+    const hash = await wc.writeContract({
+        address: resolveAddress(net),
+        abi: (await import('../abis/PasosDeJesusCredentials.json', { with: { type: 'json' } })).default,
+        functionName: 'revokeRole',
+        args: ['0x9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a6', addr],
+        chain: wc.chain,
+        account: wc.account,
+    });
+    console.log(ct('cred.revoked_minter', addr, net, hash));
+}
+async function revokeCredential(args) {
+    const net = getArg(args, '--network');
+    const tokenId = parseInt(getArg(args, '--token-id') || '');
+    const addr = getArg(args, '--address');
+    const amount = parseInt(getArg(args, '--amount') || '1');
+    if (!net || isNaN(tokenId) || !addr)
+        throw new Error(ct('cred.args_missing_revoke'));
+    const key = process.env.PRIVATE_KEY;
+    if (!key)
+        throw new Error(ct('cred.no_privkey'));
+    const { createWalletClient, http } = await import('viem');
+    const { privateKeyToAccount } = await import('viem/accounts');
+    const { default: credentialsAbi } = await import('../abis/PasosDeJesusCredentials.json', { with: { type: 'json' } });
+    const account = privateKeyToAccount(key);
+    const wc = createWalletClient({ chain: await getChain(net), transport: http(), account });
+    const hash = await wc.writeContract({
+        address: resolveAddress(net),
+        abi: credentialsAbi,
+        functionName: 'revokeCredential',
+        args: [addr, BigInt(tokenId), BigInt(amount)],
+        chain: wc.chain,
+        account: wc.account,
+    });
+    console.log(ct('cred.revoked', String(tokenId), String(amount), addr, net, hash));
+}
+function isAdminCommand(cmd) {
+    return cmd === 'grant-minter' || cmd === 'revoke-minter' || cmd === 'set-site-uri';
+}
+function deploymentsExist() {
+    return fs.existsSync(getDeploymentsDir());
+}
+function hasAdminKey() {
+    return !!process.env.CREDENTIALS_PRIVATE_KEY;
+}
+export async function runCredentials(args) {
+    if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+        usage();
+        process.exit(0);
+    }
+    const command = args[0];
+    const rest = args.slice(1);
+    if (isAdminCommand(command) && !hasAdminKey()) {
+        problem(ct('cred.no_admin_key'));
+        process.exit(1);
+    }
+    try {
+        switch (command) {
+            case 'list-types': {
+                const net = getArg(rest, '--network') || process.env.NEXT_PUBLIC_NETWORK || 'celoSepolia';
+                await listTypes(net);
+                break;
+            }
+            case 'mint': {
+                await mint(rest);
+                break;
+            }
+            case 'register-type': {
+                await registerType(rest);
+                break;
+            }
+            case 'recompose-image': {
+                await recomposeImage(rest);
+                break;
+            }
+            case 'set-max-supply': {
+                await setMaxSupply(rest);
+                break;
+            }
+            case 'set-site-uri': {
+                if (!hasAdminKey()) {
+                    problem(ct('cred.no_admin_key'));
+                    process.exit(1);
+                }
+                await setSiteUri(rest);
+                break;
+            }
+            case 'sync-cache': {
+                const net = getArg(rest, '--network') || process.env.NEXT_PUBLIC_NETWORK || 'celoSepolia';
+                await syncCache(net);
+                break;
+            }
+            case 'grant-minter': {
+                if (!hasAdminKey()) {
+                    problem(ct('cred.no_admin_key'));
+                    process.exit(1);
+                }
+                await grantMinter(rest);
+                break;
+            }
+            case 'revoke-minter': {
+                if (!hasAdminKey()) {
+                    problem(ct('cred.no_admin_key'));
+                    process.exit(1);
+                }
+                await revokeMinter(rest);
+                break;
+            }
+            case 'revoke-credential': {
+                await revokeCredential(rest);
+                break;
+            }
+            default:
+                problem(ct('cred.unknown_command', command));
+                usage();
+                process.exit(1);
+        }
+    }
+    catch (err) {
+        problem(err.message || String(err));
+        process.exit(1);
+    }
+}
+export { deploymentsExist, hasAdminKey };

package/dist/tasks/principles.d.ts

@@ -0,0 +1 @@
+export declare function runAiPrinciples(): Promise<void>;

package/dist/tasks/principles.js

@@ -0,0 +1,37 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { findIaDir } from '@pasosdejesus/m/dist/tasks/util.js';
+import { success, problem } from '@pasosdejesus/m/dist/util/colors.js';
+import { setClipboard } from '@pasosdejesus/m/dist/tasks/edit.js';
+import { createTranslator } from '@pasosdejesus/m/dist/i18n/createTranslator.js';
+import { detectLocale } from '@pasosdejesus/m/dist/util/locale.js';
+import commonCli from '@pasosdejesus/m/dist/i18n/common-cli.js';
+const t = createTranslator(detectLocale(), {
+    en: {
+        'principles.no_ia_dir': 'ia/ directory not found in the project.',
+        'principles.read_error': 'Error reading ia/principles.md',
+        'principles.copied': '📋 principles.md copied to clipboard ({{0}}KB)',
+    },
+    es: {
+        'principles.no_ia_dir': 'No se encontró ia/ en el proyecto.',
+        'principles.read_error': 'Error al leer ia/principles.md',
+        'principles.copied': '📋 principles.md copiado al portapapeles ({{0}}KB)',
+    },
+}, commonCli);
+export async function runAiPrinciples() {
+    const iaDir = await findIaDir();
+    if (!iaDir) {
+        problem(t('principles.no_ia_dir'));
+        return;
+    }
+    const principlesPath = join(iaDir, 'principles.md');
+    try {
+        const content = await readFile(principlesPath, 'utf-8');
+        console.log(content);
+        await setClipboard(content);
+        success(t('principles.copied', Math.round(content.length / 1024).toString()));
+    }
+    catch {
+        problem(t('principles.read_error'));
+    }
+}