@sphereon/gx-agent-cli/dist/lib/vc.js

Gaia-X Compliance Client CLI

import { program } from 'commander';
import { printTable } from 'console-table-printer';
import fs from 'fs';
import { asDID, convertDidWebToHost, exportToDIDDocument, getAgent, getVcSubjectIdAsString, getVcType } from '@sphereon/gx-agent';
import nock from 'nock';
const vc = program.command('vc').description('Generic Verifiable Credential commands');
vc.command('issue')
    .description('Issues a Verifiable Credential using a Credential from an input file')
    .requiredOption('-f, --input-file <string>', 'File containing an unsigned credential')
    .option('-d, --did <string>', 'Use domain or did, otherwise will be deducted from the input credential issuer value')
    .option('-kid, --key-identifier <string>', 'Use a specific key identifier, otherwise will be deducted from the input credential issuer value')
    .option('-p, --persist', 'Persist the credential. If not provided the credential will not be stored in the agent')
    .option('--show', 'Print the Verifiable Credential to console')
    .action(async (cmd) => {
    const agent = await getAgent();
    try {
        const credential = JSON.parse(fs.readFileSync(cmd.inputFile, 'utf-8'));
        const did = cmd.did
            ? await asDID(cmd.did)
            : typeof credential.issuer === 'string'
                ? credential.issuer
                : credential.issuer
                    ? credential.issuer.id
                    : await asDID();
        const id = await agent.didManagerGet({ did });
        const didDoc = await exportToDIDDocument(id);
        const url = `https://${convertDidWebToHost(did)}`;
        if (!credential.issuer) {
            credential.issuer = did;
        }
        nock.cleanAll();
        nock(url)
            .get(`/.well-known/did.json`)
            .times(10)
            .reply(200, {
            ...didDoc,
        });
        const vc = await agent.issueVerifiableCredential({
            credential,
            keyRef: cmd.keyIdentifier,
            domain: did,
            persist: cmd.persist,
        });
        printTable([
            {
                types: vc.verifiableCredential.type.toString().replace('VerifiableCredential,', ''),
                issuer: vc.verifiableCredential.issuer,
                subject: vc.verifiableCredential.credentialSubject.id,
                'issuance-date': vc.verifiableCredential.issuanceDate,
                id: vc.hash,
                persisted: cmd.persist === true,
            },
        ]);
        if (cmd.show) {
            console.log(JSON.stringify(vc.verifiableCredential, null, 2));
        }
    }
    catch (e) {
        console.error(e.message);
        throw e;
    }
    finally {
        nock.cleanAll();
    }
});
vc.command('list')
    .description('Lists al persisted Verifiable Credentials')
    .option('-iss, --issuer <string>', 'domain or did of the issuer')
    .option('-t, --type <string>', 'Type of the VerifiableCredential you want to see. You can select from "LegalPerson", "ServiceOffering", "ParticipantCredential", "ServiceOfferingCredentialExperimental" or any other type that you\'ve saved via this agent')
    .action(async (cmd) => {
    const agent = await getAgent();
    try {
        let uniqueCredentials = await agent.dataStoreORMGetVerifiableCredentials({
            order: [
                {
                    column: 'issuanceDate',
                    direction: 'ASC',
                },
            ],
        });
        if (cmd.issuer) {
            const issuer = await asDID(cmd.issuer);
            uniqueCredentials = uniqueCredentials.filter((uvc) => uvc.verifiableCredential.issuer === issuer);
        }
        if (cmd.type) {
            uniqueCredentials = uniqueCredentials.filter((uvc) => getVcType(uvc.verifiableCredential).trim() === cmd.type.trim());
        }
        printTable(uniqueCredentials.map((vc) => {
            return {
                types: getVcType(vc.verifiableCredential),
                issuer: vc.verifiableCredential.issuer,
                subject: getVcSubjectIdAsString(vc.verifiableCredential),
                'issuance-date': vc.verifiableCredential.issuanceDate,
                id: vc.hash,
            };
        }));
    }
    catch (e) {
        console.error(e);
    }
});
vc.command('verify')
    .description('Verifies a Verifiable Credential using a Credential from an input file or stored in the agent')
    .option('-f, --input-file <string>', 'File containing a Verifiable Credential')
    .option('-id, --vc-id <string>', 'Use a persisted VC as input for verification')
    .option('--show', 'Print the Verifiable Credential to console')
    .action(async (cmd) => {
    const agent = await getAgent();
    if (!cmd.inputFile && !cmd.vcId) {
        throw Error('Either a Verifiable Credential input file or the id of a stored Verifiable Credential needs to be supplied');
    }
    else if (cmd.inputFile && cmd.vcId) {
        throw Error('Cannot both have a Verifiable Credential input file and the id of a stored Verifiable Credential');
    }
    try {
        const verifiableCredential = cmd.inputFile
            ? JSON.parse(fs.readFileSync(cmd.inputFile, 'utf-8'))
            : await agent.dataStoreGetVerifiableCredential({ hash: cmd.vcId });
        const did = cmd.did
            ? await asDID(cmd.did)
            : typeof verifiableCredential.issuer === 'string'
                ? verifiableCredential.issuer
                : verifiableCredential.issuer
                    ? verifiableCredential.issuer.id
                    : await asDID();
        let id;
        try {
            id = await agent.didManagerGet({ did });
            const didDoc = await exportToDIDDocument(id);
            const url = `https://${convertDidWebToHost(did)}`;
            nock.cleanAll();
            nock(url)
                .get(`/.well-known/did.json`)
                .times(10)
                .reply(200, {
                ...didDoc,
            });
        }
        catch (e) {
            // DID not hosted by us, which is fine
        }
        try {
            const result = await agent.checkVerifiableCredential({ verifiableCredential });
            printTable([
                {
                    types: verifiableCredential.type.toString().replace('VerifiableCredential,', ''),
                    issuer: verifiableCredential.issuer,
                    subject: verifiableCredential.credentialSubject.id,
                    'issuance-date': verifiableCredential.issuanceDate,
                    valid: JSON.stringify(result).toString(),
                },
            ]);
        }
        catch (e) {
            console.error(e.message);
        }
        if (cmd.show === true) {
            console.log(JSON.stringify(verifiableCredential, null, 2));
        }
    }
    catch (e) {
        console.error(e.message);
    }
    finally {
        nock.cleanAll();
    }
});