cli.ts

#!/usr/bin/env node
import { Command, Option } from "commander";
import fs from 'fs'
import path from 'path'
import * as mime from "mime-types";

import { ContentType, Document, VerificationResult, IIssuer, IVerifier } from "./api-spec.js";

// To support extra implementations: add imports similar to the one for solid
import { SolidApi, SolidConfiguration } from "./implementations/solid/api.js";

// To support extra implementations: extend the array below
const implementations = ["solid"];

const program = new Command();

// To support extra implementations: extend the return type (SoldApi | AnotherApi | ...)
function createApi(implementation: string, configFile: string): SolidApi {
  let config;
  let api;
  if (!fs.existsSync(configFile)) {
    throw new Error(`Configuration file not found: ${configFile}`);
  }
  const rawData = fs.readFileSync(configFile, 'utf-8');
  try {
    config = JSON.parse(rawData);
  } catch (error) {
    throw new Error(`Error parsing configuration file: ${error}`);
  }
  switch (implementation) {
    // To support extra implementations: add cases, one per string in the implementations array
    case "solid":
      api = new SolidApi(config as SolidConfiguration);
      break;
    default:
      throw new Error(`Unsupported implementation: ${implementation}`);
  }
  return api;
}

function readDocumentFromFile(filePath: string): Document {
  if (!fs.existsSync(filePath)) {
    throw new Error(`File not found: ${filePath}`);
  }
  return {
    content: fs.readFileSync(filePath, 'utf-8'),
    contentType: mime.lookup(path.extname(filePath)) as ContentType
  };
}

function createCommandWithCommonOptions(name: string, description: string): Command {
  return new Command(name)
    .description(description)
    .addOption(new Option("-m, --implementation <implementation>", "The API implementation").choices(implementations).makeOptionMandatory())
    .addOption(new Option("-c, --config-file <configuration file>", "Configuration file compliant with the API implementation").makeOptionMandatory());
}

const setupCommand = createCommandWithCommonOptions("setup", "Setup issuer and verifier")
  .action(async (options: any) => {
    try {
      if (!fs.existsSync(options.configFile)) {
        throw new Error(`Configuration file not found: ${options.configFile}`);
      }
      const api = createApi(options.implementation, options.configFile);
      await api.setup();
      console.log("Setup completed.");
    } catch (error) {
      console.error("Setup error:", error);
      process.exit(2);
    };
  });

const issueCommand = createCommandWithCommonOptions("issue", "Issue a verifiable credential")
  .addOption(new Option("-i, --input-file <input file>", "The input file").makeOptionMandatory())
  .addOption(new Option("-o, --output-file <output file>", "The output file (if not provided, output to console)"))
  .action(async (options: any) => {
    try {
      if (!fs.existsSync(options.configFile)) {
        throw new Error(`Configuration file not found: ${options.configFile}`);
      }
      if (!fs.existsSync(options.inputFile)) {
        throw new Error(`Input file not found: ${options.inputFile}`);
      }
      const api = createApi(options.implementation, options.configFile);
      const document = readDocumentFromFile(options.inputFile);
      const signedDocument = await api.issue(document);
      if (options.outputFile) {
        const outputDir = path.dirname(options.outputFile);
        if (!fs.existsSync(outputDir)) {
          fs.mkdirSync(outputDir, { recursive: true });
        }
        fs.writeFileSync(options.outputFile, signedDocument.content);
        console.log(`Verifiable credential written to ${options.outputFile}.`);
      } else {
        console.log(signedDocument);
      }
    } catch (error) {
      console.error("Issue error:", error);
      process.exit(2);
    };
  });

const verifyCommand = createCommandWithCommonOptions("verify", "Verify a verifiable credential")
  .addOption(new Option("-i, --input-file <input file>", "The input file").makeOptionMandatory())
  .action(async (options: any) => {
    try {
      if (!fs.existsSync(options.configFile)) {
        throw new Error(`Configuration file not found: ${options.configFile}`);
      }
      if (!fs.existsSync(options.inputFile)) {
        throw new Error(`Input file not found: ${options.inputFile}`);
      }
      const api = createApi(options.implementation, options.configFile);
      const document = readDocumentFromFile(options.inputFile);
      const publicKey = await api.retrievePublicKey();
      const verificationResult = await api.verify(document, publicKey);
      console.log(`Verification result: ${verificationResult}.`);
      if (verificationResult !== "pass") {
        process.exit(1);
      }
    } catch (error) {
      console.error("Verify error:", error);
      process.exit(2);
    }
  });

program
  .name("vc-proto")
  .description("Verifiable Credentials prototyping library command line app")
  .version("0.0.0")
  .addCommand(setupCommand)
  .addCommand(issueCommand)
  .addCommand(verifyCommand);

program.parseAsync(process.argv);