autotel-pact 0.2.0

package/dist/cli.js

@@ -0,0 +1,656 @@
+#!/usr/bin/env node
+import path from 'path';
+import { existsSync, statSync, readdirSync, readFileSync } from 'fs';
+import 'fs/promises';
+
+// src/broker.ts
+function authHeaders(config) {
+  const headers = {
+    Accept: "application/json"
+  };
+  if (config.token) {
+    headers.Authorization = `Bearer ${config.token}`;
+  } else if (config.username && config.password) {
+    const encoded = Buffer.from(`${config.username}:${config.password}`).toString("base64");
+    headers.Authorization = `Basic ${encoded}`;
+  }
+  return headers;
+}
+function trimBaseUrl(url) {
+  return url.replace(/\/$/, "");
+}
+function parseBrokerVerificationResult(consumer, provider, json) {
+  if (!json || typeof json !== "object") return null;
+  const body = json;
+  const success = body.success === true || body.success === void 0 && body.result === "success";
+  const verifiedAt = typeof body.verifiedAt === "string" ? body.verifiedAt : typeof body.verified_at === "string" ? body.verified_at : typeof body.createdAt === "string" ? body.createdAt : void 0;
+  return {
+    consumer,
+    provider,
+    success: !!success,
+    verifiedAt
+  };
+}
+async function fetchBrokerVerifications(config, pairs) {
+  const base = trimBaseUrl(config.baseUrl);
+  const headers = authHeaders(config);
+  const results = [];
+  for (const { consumer, provider } of pairs) {
+    const url = `${base}/pacts/provider/${encodeURIComponent(provider)}/consumer/${encodeURIComponent(consumer)}/latest/verification-results`;
+    try {
+      const res = await fetch(url, { headers });
+      if (!res.ok) {
+        results.push({
+          consumer,
+          provider,
+          success: false,
+          error: `HTTP ${res.status} ${res.statusText}`.trim()
+        });
+        continue;
+      }
+      const json = await res.json();
+      const parsed = parseBrokerVerificationResult(consumer, provider, json);
+      results.push(
+        parsed ?? {
+          consumer,
+          provider,
+          success: false,
+          error: "Unparseable broker response"
+        }
+      );
+    } catch (error) {
+      results.push({
+        consumer,
+        provider,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return results;
+}
+function brokerConfigFromEnv() {
+  const baseUrl = process.env.PACT_BROKER_BASE_URL;
+  if (!baseUrl) return void 0;
+  return {
+    baseUrl,
+    token: process.env.PACT_BROKER_TOKEN,
+    username: process.env.PACT_BROKER_USERNAME,
+    password: process.env.PACT_BROKER_PASSWORD
+  };
+}
+
+// src/types.ts
+var LEDGER_ENTRY_SPEC = "autotel-pact-ledger-entry/v0.2.0";
+var AUDIT_MATRIX_SPEC = "autotel-pact-audit-matrix/v0.2.0";
+function isInteractionLedgerEntry(entry) {
+  return entry.type !== "provider_verification_run";
+}
+function isProviderVerificationRun(entry) {
+  return entry.type === "provider_verification_run";
+}
+
+// src/ledger-normalize.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function normalizeLedgerRecord(parsed) {
+  if (!isRecord(parsed) || parsed.spec !== LEDGER_ENTRY_SPEC) return null;
+  const { consumer, provider, observed_at } = parsed;
+  if (typeof consumer !== "string" || typeof provider !== "string" || typeof observed_at !== "string") {
+    return null;
+  }
+  if (parsed.type === "provider_verification_run") {
+    if (typeof parsed.error !== "string") return null;
+    const entry2 = {
+      type: "provider_verification_run",
+      spec: LEDGER_ENTRY_SPEC,
+      consumer,
+      provider,
+      outcome: "failed",
+      source: parsed.source === "production" ? "production" : "test",
+      role: "provider",
+      observed_at,
+      error: parsed.error
+    };
+    if (typeof parsed.run_id === "string") entry2.run_id = parsed.run_id;
+    if (typeof parsed.git_sha === "string") entry2.git_sha = parsed.git_sha;
+    if (typeof parsed.trace_id === "string") entry2.trace_id = parsed.trace_id;
+    if (typeof parsed.span_id === "string") entry2.span_id = parsed.span_id;
+    return entry2;
+  }
+  if (typeof parsed.interaction !== "string") return null;
+  const states = Array.isArray(parsed.states) ? parsed.states.filter((s) => typeof s === "string") : [];
+  const entry = {
+    type: "interaction",
+    spec: LEDGER_ENTRY_SPEC,
+    consumer,
+    provider,
+    interaction: parsed.interaction,
+    states,
+    kind: parsed.kind === "http" ? "http" : "message",
+    outcome: parsed.outcome === "failed" ? "failed" : "passed",
+    source: parsed.source === "production" ? "production" : "test",
+    role: parsed.role === "provider" ? "provider" : "consumer",
+    duration_ms: typeof parsed.duration_ms === "number" && parsed.duration_ms >= 0 ? parsed.duration_ms : 0,
+    observed_at
+  };
+  if (typeof parsed.interaction_id === "string" && parsed.interaction_id.length > 0) {
+    entry.interaction_id = parsed.interaction_id;
+  }
+  if (typeof parsed.trace_id === "string") entry.trace_id = parsed.trace_id;
+  if (typeof parsed.span_id === "string") entry.span_id = parsed.span_id;
+  if (typeof parsed.run_id === "string") entry.run_id = parsed.run_id;
+  if (typeof parsed.git_sha === "string") entry.git_sha = parsed.git_sha;
+  if (typeof parsed.error === "string") entry.error = parsed.error;
+  return entry;
+}
+
+// src/ledger.ts
+var DEFAULT_DIR = ".autotel-pact";
+function resolveLedgerDir(opts = {}) {
+  return path.resolve(process.cwd(), opts.dir ?? process.env.AUTOTEL_PACT_LEDGER_DIR ?? DEFAULT_DIR);
+}
+function readLedger(opts = {}) {
+  const dir = resolveLedgerDir(opts);
+  if (!existsSync(dir)) return [];
+  const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+  const entries = [];
+  for (const file of files) {
+    const text = readFileSync(path.join(dir, file), "utf8");
+    for (const line of text.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const normalized = normalizeLedgerRecord(JSON.parse(line));
+        if (normalized) entries.push(normalized);
+      } catch {
+      }
+    }
+  }
+  return entries;
+}
+Promise.resolve();
+function listPactFiles(dir) {
+  if (!existsSync(dir) || !statSync(dir).isDirectory()) return [];
+  const out = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...listPactFiles(full));
+    } else if (entry.isFile() && entry.name.endsWith(".json")) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+function extractInteractionId(metadata) {
+  if (!metadata) return void 0;
+  const id = metadata.interactionId ?? metadata.interaction_id;
+  return typeof id === "string" && id.length > 0 ? id : void 0;
+}
+function interactionsFromPactFile(pact) {
+  const consumer = pact.consumer?.name;
+  const provider = pact.provider?.name;
+  if (!consumer || !provider) return [];
+  const keys = [];
+  for (const m of pact.messages ?? []) {
+    keys.push({
+      consumer,
+      provider,
+      interaction: m.description,
+      kind: "message",
+      interactionId: extractInteractionId(m.metadata)
+    });
+  }
+  for (const i of pact.interactions ?? []) {
+    keys.push({
+      consumer,
+      provider,
+      interaction: i.description,
+      kind: "http",
+      interactionId: extractInteractionId(i.metadata)
+    });
+  }
+  return keys;
+}
+function parsePactFile(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+// src/audit.ts
+var DEFAULT_PACTS_DIR = "./pacts";
+var DEFAULT_WINDOW_DAYS = 14;
+function keyOf(k) {
+  const identity = k.interactionId ?? k.interaction;
+  return `${k.consumer}::${k.provider}::${k.kind}::${identity}`;
+}
+function pairKey(consumer, provider) {
+  return `${consumer}::${provider}`;
+}
+function inWindow(observedAt, cutoff) {
+  const t = Date.parse(observedAt);
+  return Number.isFinite(t) && t >= cutoff;
+}
+function computeAuditMatrix(input) {
+  const windowDays = input.windowDays ?? DEFAULT_WINDOW_DAYS;
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const cutoff = now.getTime() - windowDays * 24 * 60 * 60 * 1e3;
+  const verificationFailures = [];
+  const recentInteractions = [];
+  for (const entry of input.ledger) {
+    if (!inWindow(entry.observed_at, cutoff)) continue;
+    if (isProviderVerificationRun(entry)) {
+      verificationFailures.push(entry);
+      continue;
+    }
+    if (isInteractionLedgerEntry(entry)) {
+      recentInteractions.push(entry);
+    }
+  }
+  const brokerByPair = /* @__PURE__ */ new Map();
+  for (const b of input.brokerVerifications ?? []) {
+    brokerByPair.set(pairKey(b.consumer, b.provider), b);
+  }
+  const testSeenByKey = /* @__PURE__ */ new Map();
+  const prodSeenByKey = /* @__PURE__ */ new Map();
+  const providerVerifiedByKey = /* @__PURE__ */ new Map();
+  const anyObservedByKey = /* @__PURE__ */ new Map();
+  for (const entry of recentInteractions) {
+    const k = keyOf({
+      consumer: entry.consumer,
+      provider: entry.provider,
+      interaction: entry.interaction,
+      kind: entry.kind,
+      interactionId: entry.interaction_id
+    });
+    const push = (map) => {
+      const arr = map.get(k) ?? [];
+      arr.push(entry);
+      map.set(k, arr);
+    };
+    push(anyObservedByKey);
+    if (entry.source === "test" && entry.role === "consumer") {
+      push(testSeenByKey);
+    }
+    if (entry.source === "production") {
+      push(prodSeenByKey);
+    }
+    if (entry.role === "provider" && entry.outcome === "passed") {
+      push(providerVerifiedByKey);
+    }
+  }
+  const contractedByKey = /* @__PURE__ */ new Map();
+  for (const c of input.contracted) {
+    contractedByKey.set(keyOf(c), c);
+  }
+  const rows = [];
+  function pushRow(parts, k, isContracted) {
+    const testObs = testSeenByKey.get(k) ?? [];
+    const prodObs = prodSeenByKey.get(k) ?? [];
+    const providerObs = providerVerifiedByKey.get(k) ?? [];
+    const allObs = anyObservedByKey.get(k) ?? [];
+    const latest = allObs.toSorted(
+      (a, b) => b.observed_at.localeCompare(a.observed_at)
+    )[0];
+    const broker = brokerByPair.get(pairKey(parts.consumer, parts.provider));
+    rows.push({
+      consumer: parts.consumer,
+      provider: parts.provider,
+      interaction: parts.interaction,
+      interaction_id: parts.interactionId ?? latest?.interaction_id,
+      kind: parts.kind,
+      contracted: isContracted,
+      observed: testObs.length > 0 || prodObs.length > 0,
+      test_seen: testObs.length > 0,
+      prod_seen: prodObs.length > 0,
+      provider_verified: providerObs.length > 0,
+      broker_verified: broker?.success === true,
+      broker_verified_at: broker?.verifiedAt,
+      broker_error: broker?.error,
+      last_observed_at: latest?.observed_at,
+      last_outcome: latest?.outcome
+    });
+  }
+  for (const [k, contracted] of contractedByKey) {
+    pushRow(contracted, k, true);
+  }
+  for (const [k, observations] of anyObservedByKey) {
+    if (contractedByKey.has(k)) continue;
+    const first = observations[0];
+    pushRow(
+      {
+        consumer: first.consumer,
+        provider: first.provider,
+        interaction: first.interaction,
+        kind: first.kind,
+        interactionId: first.interaction_id
+      },
+      k,
+      false
+    );
+  }
+  rows.sort(
+    (a, b) => a.consumer.localeCompare(b.consumer) || a.provider.localeCompare(b.provider) || a.interaction.localeCompare(b.interaction)
+  );
+  const counts = {
+    total: rows.length,
+    contracted: rows.filter((r) => r.contracted).length,
+    observed: rows.filter((r) => r.observed).length,
+    contracted_and_test_seen: rows.filter((r) => r.contracted && r.test_seen).length,
+    contracted_not_test_seen: rows.filter((r) => r.contracted && !r.test_seen).length,
+    test_or_prod_seen_not_contracted: rows.filter(
+      (r) => !r.contracted && (r.test_seen || r.prod_seen)
+    ).length,
+    test_seen: rows.filter((r) => r.test_seen).length,
+    prod_seen: rows.filter((r) => r.prod_seen).length,
+    provider_verified: rows.filter((r) => r.provider_verified).length,
+    broker_verified: rows.filter((r) => r.broker_verified).length
+  };
+  const matrix = {
+    spec: AUDIT_MATRIX_SPEC,
+    rows,
+    counts,
+    window_days: windowDays,
+    generated_at: now.toISOString()
+  };
+  if (verificationFailures.length > 0) {
+    matrix.verification_failures = verificationFailures;
+  }
+  return matrix;
+}
+async function runAudit(opts = {}) {
+  const pactsDir = path.resolve(process.cwd(), opts.pactsDir ?? DEFAULT_PACTS_DIR);
+  const contracted = [];
+  const pairs = /* @__PURE__ */ new Set();
+  for (const file of listPactFiles(pactsDir)) {
+    const pact = parsePactFile(file);
+    if (!pact) continue;
+    const interactions = interactionsFromPactFile(pact);
+    contracted.push(...interactions);
+    const consumer = pact.consumer?.name;
+    const provider = pact.provider?.name;
+    if (consumer && provider) {
+      pairs.add(pairKey(consumer, provider));
+    }
+  }
+  const ledger = readLedger(opts);
+  let brokerVerifications;
+  if (opts.broker) {
+    brokerVerifications = await fetchBrokerVerifications(opts.broker, [...pairs].map((p) => {
+      const [consumer, provider] = p.split("::");
+      return { consumer, provider };
+    }));
+  }
+  return computeAuditMatrix({
+    contracted,
+    ledger,
+    brokerVerifications,
+    windowDays: opts.windowDays
+  });
+}
+
+// src/labels.ts
+var CLI_COLUMNS = {
+  STATUS: "STATUS",
+  CONTRACTED: "CONTRACTED",
+  TEST_SEEN: "TEST_SEEN",
+  PROD_SEEN: "PROD_SEEN",
+  PROVIDER_VERIFIED: "PROVIDER_VERIFIED",
+  BROKER_VERIFIED: "BROKER_VERIFIED",
+  PAIR: "CONSUMER \u2192 PROVIDER",
+  KIND: "KIND",
+  INTERACTION: "INTERACTION"
+};
+function formatYesNo(value) {
+  return value ? "yes" : "no";
+}
+
+// src/cli.ts
+var HELP_TEXT = `autotel-pact audit \u2014 runtime evidence for Pact contracts
+
+USAGE
+  autotel-pact audit [options]
+
+OPTIONS
+  --pacts <dir>         Directory containing pact files (default: ./pacts)
+  --ledger <dir>        Directory containing ledger files (default: .autotel-pact)
+  --window <days>       How many days back to consider observations recent (default: 14)
+  --gate                Exit non-zero if any contracted interaction was not seen in test
+  --gate=strict         Also exit non-zero on observations with no matching contract
+  --gate=broker         Exit non-zero if broker is configured and any row lacks broker verification
+  --broker-url <url>    Pact Broker base URL (or PACT_BROKER_BASE_URL)
+  --broker-token <tok>  Pact Broker bearer token (or PACT_BROKER_TOKEN)
+  --json                Emit machine-readable JSON instead of a table
+  --help, -h            Show this help
+
+ENVIRONMENT
+  AUTOTEL_PACT_RUN_ID         Tag ledger entries with a run id
+  AUTOTEL_PACT_LEDGER_DIR     Override default ledger directory
+  PACT_BROKER_BASE_URL        Broker base URL
+  PACT_BROKER_TOKEN           Broker bearer token
+  PACT_BROKER_USERNAME        Broker basic auth username
+  PACT_BROKER_PASSWORD        Broker basic auth password
+`;
+function parseDuration(value) {
+  const m = /^(\d+)(d?)$/.exec(value);
+  if (!m) throw new Error(`Invalid --window value: ${value}`);
+  return Number.parseInt(m[1], 10);
+}
+function requireValue(argv, i, flag) {
+  const value = argv[i];
+  if (value === void 0 || value.startsWith("--")) {
+    throw new Error(`Missing value for ${flag}`);
+  }
+  return value;
+}
+function parseArgs(argv) {
+  const args = { gate: "off", json: false, help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    switch (a) {
+      case "--help":
+      case "-h": {
+        args.help = true;
+        break;
+      }
+      case "--json": {
+        args.json = true;
+        break;
+      }
+      case "--gate": {
+        args.gate = "on";
+        break;
+      }
+      case "--gate=strict": {
+        args.gate = "strict";
+        break;
+      }
+      case "--gate=broker": {
+        args.gate = "broker";
+        break;
+      }
+      case "--pacts": {
+        args.pactsDir = requireValue(argv, ++i, "--pacts");
+        break;
+      }
+      case "--ledger": {
+        args.ledgerDir = requireValue(argv, ++i, "--ledger");
+        break;
+      }
+      case "--window": {
+        args.windowDays = parseDuration(requireValue(argv, ++i, "--window"));
+        break;
+      }
+      case "--broker-url": {
+        args.brokerUrl = requireValue(argv, ++i, "--broker-url");
+        break;
+      }
+      case "--broker-token": {
+        args.brokerToken = requireValue(argv, ++i, "--broker-token");
+        break;
+      }
+      default: {
+        if (a.startsWith("--pacts=")) {
+          const value = a.slice("--pacts=".length);
+          if (!value) throw new Error("Missing value for --pacts");
+          args.pactsDir = value;
+        } else if (a.startsWith("--ledger=")) {
+          const value = a.slice("--ledger=".length);
+          if (!value) throw new Error("Missing value for --ledger");
+          args.ledgerDir = value;
+        } else if (a.startsWith("--window=")) {
+          const value = a.slice("--window=".length);
+          if (!value) throw new Error("Missing value for --window");
+          args.windowDays = parseDuration(value);
+        } else if (a.startsWith("--broker-url=")) {
+          const value = a.slice("--broker-url=".length);
+          if (!value) throw new Error("Missing value for --broker-url");
+          args.brokerUrl = value;
+        } else if (a.startsWith("--broker-token=")) {
+          const value = a.slice("--broker-token=".length);
+          if (!value) throw new Error("Missing value for --broker-token");
+          args.brokerToken = value;
+        } else if (a === "audit") continue;
+        else throw new Error(`Unknown argument: ${a}`);
+      }
+    }
+  }
+  return args;
+}
+function statusLabel(r) {
+  if (r.contracted && r.test_seen) return "OK";
+  if (r.contracted && !r.test_seen) return "STALE";
+  return "SHADOW";
+}
+function formatTable(matrix) {
+  const lines = [
+    `Window: last ${matrix.window_days} day(s)`,
+    `Generated: ${matrix.generated_at}`,
+    ""
+  ];
+  if (matrix.rows.length === 0) {
+    lines.push("No contracts or observations found.");
+    return lines.join("\n");
+  }
+  const header = [
+    CLI_COLUMNS.STATUS,
+    CLI_COLUMNS.CONTRACTED,
+    CLI_COLUMNS.TEST_SEEN,
+    CLI_COLUMNS.PROD_SEEN,
+    CLI_COLUMNS.PROVIDER_VERIFIED,
+    CLI_COLUMNS.BROKER_VERIFIED,
+    CLI_COLUMNS.PAIR,
+    CLI_COLUMNS.KIND,
+    CLI_COLUMNS.INTERACTION
+  ];
+  const rows = matrix.rows.map((r) => [
+    statusLabel(r),
+    formatYesNo(r.contracted),
+    formatYesNo(r.test_seen),
+    formatYesNo(r.prod_seen),
+    formatYesNo(r.provider_verified),
+    formatYesNo(r.broker_verified),
+    `${r.consumer} \u2192 ${r.provider}`,
+    r.kind,
+    r.interaction
+  ]);
+  const widths = header.map(
+    (h, i) => Math.max(h.length, ...rows.map((row) => row[i].length))
+  );
+  const fmt = (cells) => cells.map((c, i) => c.padEnd(widths[i])).join("  ");
+  lines.push(
+    fmt(header),
+    widths.map((w) => "\u2500".repeat(w)).join("  "),
+    ...rows.map((r) => fmt(r)),
+    "",
+    "Summary",
+    `  Total interactions:               ${matrix.counts.total}`,
+    `  Contracted:                       ${matrix.counts.contracted}`,
+    `  Seen in test:                     ${matrix.counts.test_seen}`,
+    `  Seen in production:               ${matrix.counts.prod_seen}`,
+    `  Provider verified (interaction):  ${matrix.counts.provider_verified}`,
+    `  Broker verified (pact-pair):      ${matrix.counts.broker_verified}`,
+    `  Contracted AND seen in test:      ${matrix.counts.contracted_and_test_seen}`,
+    `  Contracted, NOT seen in test:     ${matrix.counts.contracted_not_test_seen}  \u2190 stale confidence`,
+    `  Seen, NOT contracted:             ${matrix.counts.test_or_prod_seen_not_contracted}  \u2190 ungoverned flow`
+  );
+  if (matrix.verification_failures && matrix.verification_failures.length > 0) {
+    lines.push("", "Provider verification failures (run-level):");
+    for (const f of matrix.verification_failures) {
+      lines.push(`  ${f.consumer} \u2192 ${f.provider}: ${f.error}`);
+    }
+  }
+  const brokerErrors = /* @__PURE__ */ new Map();
+  for (const r of matrix.rows) {
+    if (r.broker_error) {
+      brokerErrors.set(`${r.consumer} \u2192 ${r.provider}`, r.broker_error);
+    }
+  }
+  if (brokerErrors.size > 0) {
+    lines.push("", "Broker unreachable / errored (verification status unknown):");
+    for (const [pair, err] of brokerErrors) {
+      lines.push(`  ${pair}: ${err}`);
+    }
+  }
+  return lines.join("\n");
+}
+function shouldFail(matrix, gate) {
+  if (gate === "off") return false;
+  if (matrix.counts.contracted_not_test_seen > 0) return true;
+  if (gate === "strict" && matrix.counts.test_or_prod_seen_not_contracted > 0) return true;
+  if (gate === "broker") {
+    const contractedRows = matrix.rows.filter((r) => r.contracted);
+    if (contractedRows.some((r) => r.broker_error)) return true;
+    if (contractedRows.some((r) => !r.broker_verified)) return true;
+  }
+  return false;
+}
+async function main(argv) {
+  let args;
+  try {
+    args = parseArgs(argv);
+  } catch (error) {
+    process.stderr.write(`${error.message}
+
+${HELP_TEXT}`);
+    return 2;
+  }
+  if (args.help) {
+    process.stdout.write(HELP_TEXT);
+    return 0;
+  }
+  const envBroker = brokerConfigFromEnv();
+  const broker = args.brokerUrl || envBroker ? {
+    baseUrl: args.brokerUrl ?? envBroker.baseUrl,
+    token: args.brokerToken ?? envBroker?.token,
+    username: envBroker?.username,
+    password: envBroker?.password
+  } : void 0;
+  const matrix = await runAudit({
+    pactsDir: args.pactsDir,
+    dir: args.ledgerDir,
+    windowDays: args.windowDays,
+    broker
+  });
+  if (args.json) {
+    process.stdout.write(JSON.stringify(matrix, null, 2) + "\n");
+  } else {
+    process.stdout.write(formatTable(matrix) + "\n");
+  }
+  return shouldFail(matrix, args.gate) ? 1 : 0;
+}
+var isDirectInvocation = typeof process !== "undefined" && process.argv[1] && (process.argv[1].endsWith("cli.js") || process.argv[1].endsWith("autotel-pact"));
+if (isDirectInvocation) {
+  main(process.argv.slice(2)).then((code) => process.exit(code)).catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+}
+
+export { main };
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map