@the-cascade-protocol/cli 0.2.0

package/src/commands/capabilities.ts

@@ -0,0 +1,235 @@
+/**
+ * cascade capabilities
+ *
+ * Output a machine-readable JSON description of all CLI commands and their
+ * parameters. Designed for consumption by AI agents and tooling.
+ */
+
+import { Command } from 'commander';
+import { printResult, type OutputOptions } from '../lib/output.js';
+
+/** Tool parameter descriptor for capabilities output */
+interface ToolParameter {
+  name: string;
+  type: string;
+  required: boolean;
+  description: string;
+  default?: string;
+  choices?: string[];
+}
+
+/** Tool descriptor for capabilities output */
+interface ToolDescriptor {
+  name: string;
+  description: string;
+  usage: string;
+  parameters: ToolParameter[];
+  examples: string[];
+  status: 'implemented';
+}
+
+/** MCP tool descriptor */
+interface McpToolDescriptor {
+  name: string;
+  description: string;
+  parameters: Record<string, { type: string; description: string; required: boolean; enum?: string[] }>;
+}
+
+/** Full capabilities output */
+interface CapabilitiesOutput {
+  name: string;
+  version: string;
+  description: string;
+  protocol: string;
+  tools: ToolDescriptor[];
+  mcpTools: McpToolDescriptor[];
+  securityModel: Record<string, string>;
+}
+
+function getCapabilities(version: string): CapabilitiesOutput {
+  return {
+    name: '@the-cascade-protocol/cli',
+    version,
+    description: 'Cascade Protocol CLI - Validate, convert, and manage health data with zero network calls',
+    protocol: 'https://cascadeprotocol.org',
+    securityModel: {
+      networkCalls: 'zero — all operations are local',
+      dataStorage: 'local filesystem only',
+      provenance: 'all agent-written data tagged with AIGenerated provenance',
+      auditLog: 'all MCP operations logged to provenance/audit-log.ttl',
+    },
+    tools: [
+      {
+        name: 'validate',
+        description: 'Validate Cascade Protocol data against SHACL shapes',
+        usage: 'cascade validate <file-or-dir> [options]',
+        parameters: [
+          { name: 'file-or-dir', type: 'string', required: true, description: 'Turtle file or directory to validate' },
+          { name: '--shapes', type: 'string', required: false, description: 'Path to custom SHACL shapes directory' },
+          { name: '--json', type: 'boolean', required: false, description: 'Output results as JSON' },
+          { name: '--verbose', type: 'boolean', required: false, description: 'Show detailed validation information' },
+        ],
+        examples: ['cascade validate record.ttl', 'cascade validate ./data/ --json'],
+        status: 'implemented',
+      },
+      {
+        name: 'convert',
+        description: 'Convert between health data formats (FHIR R4 JSON, Cascade Turtle, JSON-LD)',
+        usage: 'cascade convert [file] --from <format> --to <format> [options]',
+        parameters: [
+          { name: 'file', type: 'string', required: false, description: 'Input file (reads from stdin if omitted)' },
+          { name: '--from', type: 'string', required: true, description: 'Source format', choices: ['fhir', 'cascade'] },
+          { name: '--to', type: 'string', required: true, description: 'Target format', choices: ['turtle', 'jsonld', 'fhir'] },
+          { name: '--format', type: 'string', required: false, description: 'Output serialization format', default: 'turtle', choices: ['turtle', 'jsonld'] },
+          { name: '--json', type: 'boolean', required: false, description: 'Output results as JSON' },
+        ],
+        examples: ['cascade convert patient.json --from fhir --to turtle', 'cat data.json | cascade convert --from fhir --to turtle'],
+        status: 'implemented',
+      },
+      {
+        name: 'pod init',
+        description: 'Initialize a new Cascade Pod directory structure',
+        usage: 'cascade pod init <directory>',
+        parameters: [{ name: 'directory', type: 'string', required: true, description: 'Directory to initialize as a Cascade Pod' }],
+        examples: ['cascade pod init ./my-pod'],
+        status: 'implemented',
+      },
+      {
+        name: 'pod query',
+        description: 'Query data within a Cascade Pod by type',
+        usage: 'cascade pod query <pod-dir> [options]',
+        parameters: [
+          { name: 'pod-dir', type: 'string', required: true, description: 'Path to the Cascade Pod' },
+          { name: '--medications', type: 'boolean', required: false, description: 'Query medications' },
+          { name: '--conditions', type: 'boolean', required: false, description: 'Query conditions' },
+          { name: '--allergies', type: 'boolean', required: false, description: 'Query allergies' },
+          { name: '--lab-results', type: 'boolean', required: false, description: 'Query lab results' },
+          { name: '--all', type: 'boolean', required: false, description: 'Query all data' },
+          { name: '--json', type: 'boolean', required: false, description: 'Output as JSON' },
+        ],
+        examples: ['cascade pod query ./my-pod --medications --json', 'cascade pod query ./my-pod --all --json'],
+        status: 'implemented',
+      },
+      {
+        name: 'pod info',
+        description: 'Show Cascade Pod metadata and statistics',
+        usage: 'cascade pod info <pod-dir>',
+        parameters: [{ name: 'pod-dir', type: 'string', required: true, description: 'Path to the Cascade Pod' }],
+        examples: ['cascade pod info ./my-pod'],
+        status: 'implemented',
+      },
+      {
+        name: 'pod export',
+        description: 'Export Cascade Pod data as ZIP or directory',
+        usage: 'cascade pod export <pod-dir> [options]',
+        parameters: [
+          { name: 'pod-dir', type: 'string', required: true, description: 'Path to the Cascade Pod' },
+          { name: '--format', type: 'string', required: false, description: 'Export format', default: 'zip', choices: ['zip', 'directory'] },
+        ],
+        examples: ['cascade pod export ./my-pod', 'cascade pod export ./my-pod --format directory'],
+        status: 'implemented',
+      },
+      {
+        name: 'conformance run',
+        description: 'Run conformance test suite (53 fixtures)',
+        usage: 'cascade conformance run --suite <fixtures-dir> --self',
+        parameters: [
+          { name: '--suite', type: 'string', required: true, description: 'Path to test fixtures directory' },
+          { name: '--self', type: 'boolean', required: false, description: 'Run self-conformance tests' },
+          { name: '--json', type: 'boolean', required: false, description: 'Output results as JSON' },
+        ],
+        examples: ['cascade conformance run --suite ./fixtures --self'],
+        status: 'implemented',
+      },
+      {
+        name: 'serve',
+        description: 'Start local MCP-compatible agent server',
+        usage: 'cascade serve --mcp [options]',
+        parameters: [
+          { name: '--mcp', type: 'boolean', required: true, description: 'Enable MCP (Model Context Protocol) mode' },
+          { name: '--transport', type: 'string', required: false, description: 'Transport type', default: 'stdio', choices: ['stdio', 'sse'] },
+          { name: '--port', type: 'string', required: false, description: 'Port for SSE transport', default: '3000' },
+          { name: '--pod', type: 'string', required: false, description: 'Default Pod directory path' },
+        ],
+        examples: ['cascade serve --mcp', 'cascade serve --mcp --transport sse --port 3000'],
+        status: 'implemented',
+      },
+      {
+        name: 'capabilities',
+        description: 'Show machine-readable JSON description of all CLI tools and MCP tools',
+        usage: 'cascade capabilities',
+        parameters: [],
+        examples: ['cascade capabilities'],
+        status: 'implemented',
+      },
+    ],
+    mcpTools: [
+      {
+        name: 'cascade_pod_read',
+        description: 'Read a Cascade Pod and return a JSON summary of all contents',
+        parameters: { path: { type: 'string', description: 'Pod directory path (optional, uses CASCADE_POD_PATH)', required: false } },
+      },
+      {
+        name: 'cascade_pod_query',
+        description: 'Query records from a Pod by data type',
+        parameters: {
+          path: { type: 'string', description: 'Pod directory path (optional)', required: false },
+          dataType: { type: 'string', description: 'Data type to query', required: true, enum: ['medications', 'conditions', 'allergies', 'lab-results', 'immunizations', 'vital-signs', 'supplements', 'insurance', 'patient-profile', 'heart-rate', 'blood-pressure', 'activity', 'sleep', 'all'] },
+        },
+      },
+      {
+        name: 'cascade_validate',
+        description: 'Validate Turtle data against SHACL shapes',
+        parameters: {
+          path: { type: 'string', description: 'File or directory path', required: false },
+          content: { type: 'string', description: 'Inline Turtle content', required: false },
+        },
+      },
+      {
+        name: 'cascade_convert',
+        description: 'Convert between FHIR R4 JSON and Cascade Turtle/JSON-LD',
+        parameters: {
+          content: { type: 'string', description: 'Content to convert', required: true },
+          from: { type: 'string', description: 'Source format', required: true, enum: ['fhir', 'cascade'] },
+          to: { type: 'string', description: 'Target format', required: true, enum: ['cascade', 'fhir'] },
+          format: { type: 'string', description: 'Output format (turtle or jsonld)', required: false, enum: ['turtle', 'jsonld'] },
+        },
+      },
+      {
+        name: 'cascade_write',
+        description: 'Write a health record to a Pod with AIGenerated provenance',
+        parameters: {
+          path: { type: 'string', description: 'Pod directory path (optional)', required: false },
+          dataType: { type: 'string', description: 'Record type', required: true, enum: ['medications', 'conditions', 'allergies', 'lab-results', 'immunizations', 'vital-signs', 'supplements'] },
+          record: { type: 'object', description: 'JSON object with record fields', required: true },
+          provenance: { type: 'object', description: 'Provenance metadata (agentId, reason, confidence, sourceRecords)', required: false },
+        },
+      },
+      {
+        name: 'cascade_capabilities',
+        description: 'Describe all available tools and their schemas',
+        parameters: {},
+      },
+    ],
+  };
+}
+
+export function registerCapabilitiesCommand(program: Command): void {
+  program
+    .command('capabilities')
+    .description('Show machine-readable tool descriptions')
+    .action(() => {
+      const globalOpts = program.opts() as OutputOptions;
+      const version = program.version() ?? '0.1.0';
+      const capabilities = getCapabilities(version);
+
+      // Capabilities always outputs JSON, regardless of --json flag
+      // This is intentional: the purpose of this command is machine-readable output
+      if (globalOpts.json) {
+        printResult(capabilities, { json: true, verbose: globalOpts.verbose });
+      } else {
+        // Even in non-JSON mode, output formatted JSON for readability
+        printResult(capabilities, { json: true, verbose: globalOpts.verbose });
+      }
+    });
+}

package/src/commands/conformance.ts

@@ -0,0 +1,447 @@
+/**
+ * cascade conformance run
+ *
+ * Run conformance test suite against a CLI command or self-test.
+ *
+ * Options:
+ *   --suite <fixtures-dir>    Path to test fixtures directory
+ *   --command "<cmd>"         External command to test
+ *   --self                    Run self-conformance tests
+ *   --json                    Output results as JSON
+ *   --verbose                 Show detailed test output
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { Command } from 'commander';
+import { loadShapes, validateTurtle } from '../lib/shacl-validator.js';
+import { parseTurtle } from '../lib/turtle-parser.js';
+import { printResult, printError, printVerbose, type OutputOptions } from '../lib/output.js';
+import type { ValidationResult } from '../lib/shacl-validator.js';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/** Shape of a single conformance fixture JSON file. */
+interface ConformanceFixture {
+  id: string;
+  description: string;
+  dataType: string;
+  vocabulary: string;
+  input: Record<string, unknown>;
+  expectedOutput: {
+    turtle: string;
+    validationMode: 'shacl-valid' | 'exact-match';
+  };
+  shouldAccept: boolean;
+  tags: string[];
+  shaclConstraintViolated?: string;
+  notes?: string;
+}
+
+/** Result of running a single fixture. */
+interface FixtureResult {
+  id: string;
+  description: string;
+  dataType: string;
+  status: 'passed' | 'failed' | 'error';
+  negative: boolean;
+  details?: string;
+  validationDetails?: ValidationResult;
+}
+
+/** Aggregate report for the full suite run. */
+interface SuiteReport {
+  suite: string;
+  mode: string;
+  total: number;
+  passed: number;
+  failed: number;
+  errors: number;
+  results: FixtureResult[];
+  byDataType: Record<string, { total: number; passed: number; failed: number; errors: number }>;
+}
+
+// ---------------------------------------------------------------------------
+// Fixture loading
+// ---------------------------------------------------------------------------
+
+/**
+ * Load and parse all `.json` fixture files from the given directory.
+ * Files are sorted by id so output order is deterministic.
+ */
+function loadFixtures(suiteDir: string): ConformanceFixture[] {
+  if (!fs.existsSync(suiteDir)) {
+    throw new Error(`Fixtures directory not found: ${suiteDir}`);
+  }
+
+  const files = fs
+    .readdirSync(suiteDir)
+    .filter((f) => f.endsWith('.json'))
+    .sort();
+
+  if (files.length === 0) {
+    throw new Error(`No .json fixture files found in ${suiteDir}`);
+  }
+
+  const fixtures: ConformanceFixture[] = [];
+
+  for (const file of files) {
+    const filePath = path.join(suiteDir, file);
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    const fixture = JSON.parse(raw) as ConformanceFixture;
+    fixtures.push(fixture);
+  }
+
+  return fixtures;
+}
+
+// ---------------------------------------------------------------------------
+// Self-conformance runner
+// ---------------------------------------------------------------------------
+
+/**
+ * Run a single fixture in self-conformance mode.
+ *
+ * Positive fixtures (shouldAccept === true):
+ *   - Parse the expected turtle
+ *   - Run SHACL validation
+ *   - PASS if no violations; FAIL otherwise
+ *
+ * Negative fixtures (shouldAccept === false):
+ *   - If turtle is empty: PASS (rejection before serialization)
+ *   - If turtle is non-empty: SHACL validate — PASS if violations found, FAIL if clean
+ */
+function runSelfFixture(
+  fixture: ConformanceFixture,
+  shapesStore: ReturnType<typeof loadShapes>['store'],
+  shapeFiles: string[],
+  opts: OutputOptions,
+): FixtureResult {
+  const base: Pick<FixtureResult, 'id' | 'description' | 'dataType' | 'negative'> = {
+    id: fixture.id,
+    description: fixture.description,
+    dataType: fixture.dataType,
+    negative: !fixture.shouldAccept,
+  };
+
+  const turtle = fixture.expectedOutput.turtle;
+  const validationMode = fixture.expectedOutput.validationMode;
+
+  try {
+    if (fixture.shouldAccept) {
+      // ---- Positive fixture ----
+
+      // Step 1: Parse the turtle
+      const parseResult = parseTurtle(turtle);
+      if (!parseResult.success) {
+        return {
+          ...base,
+          status: 'failed',
+          details: `Turtle parse error: ${parseResult.errors.join('; ')}`,
+        };
+      }
+
+      // Step 2: SHACL validation
+      const validation = validateTurtle(turtle, shapesStore, shapeFiles, fixture.id);
+
+      if (validationMode === 'shacl-valid') {
+        if (validation.valid) {
+          printVerbose(`  [${fixture.id}] SHACL valid (${validation.quadCount} quads)`, opts);
+          return { ...base, status: 'passed', validationDetails: validation };
+        } else {
+          const violations = validation.results
+            .filter((r) => r.severity === 'violation')
+            .map((r) => `${r.shape}.${r.property}: ${r.message}`)
+            .join('; ');
+          return {
+            ...base,
+            status: 'failed',
+            details: `SHACL violations: ${violations}`,
+            validationDetails: validation,
+          };
+        }
+      } else if (validationMode === 'exact-match') {
+        // Exact-match: for now, verify it parses and is SHACL-valid
+        // Full normalized triple-by-triple equivalence is deferred
+        if (validation.valid) {
+          printVerbose(
+            `  [${fixture.id}] exact-match: parsed & SHACL valid (full normalization deferred)`,
+            opts,
+          );
+          return { ...base, status: 'passed', validationDetails: validation };
+        } else {
+          const violations = validation.results
+            .filter((r) => r.severity === 'violation')
+            .map((r) => `${r.shape}.${r.property}: ${r.message}`)
+            .join('; ');
+          return {
+            ...base,
+            status: 'failed',
+            details: `SHACL violations (exact-match mode): ${violations}`,
+            validationDetails: validation,
+          };
+        }
+      } else {
+        return {
+          ...base,
+          status: 'error',
+          details: `Unknown validationMode: ${validationMode as string}`,
+        };
+      }
+    } else {
+      // ---- Negative fixture ----
+
+      if (turtle === '') {
+        // Empty turtle means the SDK should reject before serialization — PASS
+        printVerbose(`  [${fixture.id}] negative: empty turtle (pre-serialization rejection)`, opts);
+        return { ...base, status: 'passed' };
+      }
+
+      // Non-empty turtle: validate and expect violations
+      const parseResult = parseTurtle(turtle);
+      if (!parseResult.success) {
+        // Parse failure on negative fixture = PASS (malformed is invalid)
+        printVerbose(`  [${fixture.id}] negative: turtle parse error (expected)`, opts);
+        return { ...base, status: 'passed', details: 'Turtle parse error (expected for negative fixture)' };
+      }
+
+      const validation = validateTurtle(turtle, shapesStore, shapeFiles, fixture.id);
+
+      if (!validation.valid) {
+        // Violations found — PASS for negative fixture
+        const violations = validation.results
+          .filter((r) => r.severity === 'violation')
+          .map((r) => `${r.shape}.${r.property}: ${r.message}`)
+          .join('; ');
+        printVerbose(`  [${fixture.id}] negative: SHACL violations found (expected): ${violations}`, opts);
+        return { ...base, status: 'passed', validationDetails: validation };
+      } else {
+        // No violations — FAIL for negative fixture
+        return {
+          ...base,
+          status: 'failed',
+          details: `Expected SHACL violations but data validated clean. Expected: ${fixture.shaclConstraintViolated ?? 'unspecified'}`,
+          validationDetails: validation,
+        };
+      }
+    }
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      ...base,
+      status: 'error',
+      details: `Unexpected error: ${message}`,
+    };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Report generation
+// ---------------------------------------------------------------------------
+
+/**
+ * Build the aggregate suite report from individual fixture results.
+ */
+function buildReport(
+  suitePath: string,
+  mode: string,
+  results: FixtureResult[],
+): SuiteReport {
+  const byDataType: SuiteReport['byDataType'] = {};
+
+  for (const r of results) {
+    if (!byDataType[r.dataType]) {
+      byDataType[r.dataType] = { total: 0, passed: 0, failed: 0, errors: 0 };
+    }
+    const group = byDataType[r.dataType];
+    group.total++;
+    if (r.status === 'passed') group.passed++;
+    else if (r.status === 'failed') group.failed++;
+    else group.errors++;
+  }
+
+  return {
+    suite: suitePath,
+    mode,
+    total: results.length,
+    passed: results.filter((r) => r.status === 'passed').length,
+    failed: results.filter((r) => r.status === 'failed').length,
+    errors: results.filter((r) => r.status === 'error').length,
+    results,
+    byDataType,
+  };
+}
+
+/**
+ * Print a human-readable report to stdout.
+ */
+function printHumanReport(report: SuiteReport, opts: OutputOptions): void {
+  console.log('');
+  console.log('Cascade Protocol Conformance Test Suite');
+  console.log('========================================');
+  console.log(`Suite: ${report.suite}`);
+  console.log(`Mode: ${report.mode === 'self' ? 'self-conformance' : report.mode}`);
+  console.log(`Fixtures: ${report.total}`);
+  console.log('');
+  console.log('Running tests...');
+  console.log('');
+
+  // Group results by dataType, preserving insertion order
+  const dataTypes: string[] = [];
+  const grouped: Record<string, FixtureResult[]> = {};
+
+  for (const r of report.results) {
+    if (!grouped[r.dataType]) {
+      grouped[r.dataType] = [];
+      dataTypes.push(r.dataType);
+    }
+    grouped[r.dataType].push(r);
+  }
+
+  for (const dt of dataTypes) {
+    const fixtures = grouped[dt];
+    console.log(`  ${dt} (${fixtures.length} fixtures)`);
+
+    for (const r of fixtures) {
+      const icon = r.status === 'passed' ? '\u2713' : r.status === 'failed' ? '\u2717' : '!';
+      const negativeTag = r.negative ? '[negative] ' : '';
+      const statusLine = `    ${icon} ${r.id}: ${negativeTag}${r.description}`;
+      console.log(statusLine);
+
+      if (r.status !== 'passed' && r.details) {
+        console.log(`      ${r.details}`);
+      }
+
+      // In verbose mode, show validation details even for passing tests
+      if (opts.verbose && r.validationDetails) {
+        const vd = r.validationDetails;
+        console.log(`      Quads: ${vd.quadCount}, Shapes: [${vd.shapesUsed.join(', ')}]`);
+        if (vd.results.length > 0) {
+          for (const issue of vd.results) {
+            console.log(`      - [${issue.severity}] ${issue.shape}.${issue.property}: ${issue.message}`);
+          }
+        }
+      }
+    }
+
+    console.log('');
+  }
+
+  // Summary line
+  const parts: string[] = [];
+  parts.push(`${report.passed} passed`);
+  if (report.failed > 0) parts.push(`${report.failed} failed`);
+  else parts.push('0 failed');
+  if (report.errors > 0) parts.push(`${report.errors} errors`);
+  else parts.push('0 errors');
+
+  console.log(`Results: ${parts.join(', ')}`);
+
+  const exitCode = report.failed > 0 || report.errors > 0 ? 1 : 0;
+  console.log(`Exit code: ${exitCode}`);
+}
+
+/**
+ * Print the JSON report using the output library.
+ */
+function printJsonReport(report: SuiteReport, opts: OutputOptions): void {
+  // Strip validationDetails from results for cleaner JSON output
+  const cleanResults = report.results.map((r) => {
+    const { validationDetails: _vd, ...rest } = r;
+    return rest;
+  });
+
+  printResult(
+    {
+      suite: report.suite,
+      mode: report.mode,
+      total: report.total,
+      passed: report.passed,
+      failed: report.failed,
+      errors: report.errors,
+      results: cleanResults,
+      byDataType: report.byDataType,
+    },
+    opts,
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Command registration
+// ---------------------------------------------------------------------------
+
+export function registerConformanceCommand(program: Command): void {
+  const conformance = program
+    .command('conformance')
+    .description('Run conformance test suite');
+
+  conformance
+    .command('run')
+    .description('Execute conformance tests')
+    .requiredOption('--suite <fixtures-dir>', 'Path to test fixtures directory')
+    .option('--command <cmd>', 'External command to test against')
+    .option('--self', 'Run self-conformance tests')
+    .action(
+      async (options: {
+        suite: string;
+        command?: string;
+        self?: boolean;
+      }) => {
+        const globalOpts = program.opts() as OutputOptions;
+
+        if (!options.command && !options.self) {
+          printError('Either --command or --self must be specified', globalOpts);
+          process.exitCode = 1;
+          return;
+        }
+
+        // External command mode: not yet supported
+        if (options.command) {
+          printError('External command mode not yet supported', globalOpts);
+          process.exitCode = 1;
+          return;
+        }
+
+        // Resolve suite directory
+        const suitePath = path.resolve(options.suite);
+        printVerbose(`Conformance suite: ${suitePath}`, globalOpts);
+        printVerbose('Running self-conformance tests', globalOpts);
+
+        try {
+          // Load fixtures
+          const fixtures = loadFixtures(suitePath);
+          printVerbose(`Loaded ${fixtures.length} fixture(s)`, globalOpts);
+
+          // Load SHACL shapes once
+          const { store: shapesStore, shapeFiles } = loadShapes();
+          printVerbose(`Loaded shapes: ${shapeFiles.join(', ')}`, globalOpts);
+
+          // Run each fixture
+          const results: FixtureResult[] = [];
+
+          for (const fixture of fixtures) {
+            const result = runSelfFixture(fixture, shapesStore, shapeFiles, globalOpts);
+            results.push(result);
+          }
+
+          // Build and output report
+          const report = buildReport(options.suite, 'self', results);
+
+          if (globalOpts.json) {
+            printJsonReport(report, globalOpts);
+          } else {
+            printHumanReport(report, globalOpts);
+          }
+
+          // Set exit code
+          process.exitCode = report.failed > 0 || report.errors > 0 ? 1 : 0;
+        } catch (err: unknown) {
+          const message = err instanceof Error ? err.message : String(err);
+          printError(`Conformance suite failed: ${message}`, globalOpts);
+          process.exitCode = 1;
+        }
+      },
+    );
+}