@synadia-ai/agent-fabric 0.0.0-stage → 0.2.0

package/dist/cli.js

@@ -0,0 +1,679 @@
+#!/usr/bin/env node
+import { createInterface } from 'node:readline';
+import { connect } from '@nats-io/transport-node';
+import { assertValidSenderName, resolveNatsConnectionBundle, withAgentReconnectDefaults, Agents, NatsAgentError } from '@synadia-ai/agents';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { RequestRejectedError } from '@synadia-ai/agent-service';
+
+var EDGE_RECORD_VERSION = 1;
+var DEFAULT_EDGE_SUBJECT = "TRACE.edges";
+var THREAD_ID_FIELD = "thread_id";
+var ROOT_ID_FIELD = "root_id";
+var SUBJECT_FORBIDDEN = /[\u0000-\u0020\u007f\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]/;
+function assertValidTraceOptions(options) {
+  if (options === void 0) return;
+  const subject = options.edgeSubject;
+  if (subject === void 0 || subject === null) return;
+  const reject = (reason) => {
+    throw new NatsAgentError(`trace.edgeSubject ${JSON.stringify(subject)}: ${reason}`);
+  };
+  if (typeof subject !== "string") reject("must be a string or null");
+  if (subject.length === 0) reject("must not be empty");
+  for (const token of subject.split(".")) {
+    if (token.length === 0) reject("must not contain an empty token");
+    if (SUBJECT_FORBIDDEN.test(token)) reject("must not contain whitespace or control characters");
+    if (token.includes("*") || token.includes(">")) reject("must not contain wildcards");
+  }
+}
+var COUNTERS_KEY = /* @__PURE__ */ Symbol.for("@synadia-ai/agent-fabric:trace-record-counts");
+var counters = (() => {
+  const g = globalThis;
+  return g[COUNTERS_KEY] ??= { published: 0, dropped: 0 };
+})();
+function countTraceRecordPublished() {
+  counters.published += 1;
+}
+function countTraceRecordDropped() {
+  counters.dropped += 1;
+}
+function traceRecordCounts() {
+  return Object.freeze({ published: counters.published, dropped: counters.dropped });
+}
+var STORAGE_KEY = /* @__PURE__ */ Symbol.for("@synadia-ai/agent-fabric:trace-scope");
+var storage = (() => {
+  const g = globalThis;
+  return g[STORAGE_KEY] ??= new AsyncLocalStorage();
+})();
+function bindActiveTrace(scope, fn) {
+  return storage.run(scope, fn);
+}
+function activeTrace() {
+  return storage.getStore();
+}
+var THREAD_ID_HEX_LEN = 32;
+var THREAD_ID_RE = new RegExp(`^[0-9a-f]{${THREAD_ID_HEX_LEN}}$`);
+function isThreadId(value) {
+  return THREAD_ID_RE.test(value);
+}
+function randomThreadId() {
+  const bytes = new Uint8Array(THREAD_ID_HEX_LEN / 2);
+  crypto.getRandomValues(bytes);
+  let out = "";
+  for (const b of bytes) out += b.toString(16).padStart(2, "0");
+  return out;
+}
+var TOOL_CALL_ID_MAX = 256;
+var LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+function validToolCallId(toolCallId) {
+  if (LONE_SURROGATE.test(toolCallId)) return false;
+  const codePoints = Array.from(toolCallId).length;
+  return codePoints > 0 && codePoints <= TOOL_CALL_ID_MAX;
+}
+function buildEdgeRecord(agent, threadId, parentId, rootId, toolCallId, turnCountHint) {
+  const recordId = randomThreadId();
+  const record = {
+    version: EDGE_RECORD_VERSION,
+    kind: "edge",
+    record_id: recordId,
+    ts: Math.floor(Date.now() / 1e3),
+    agent,
+    thread_id: threadId,
+    parent_id: parentId,
+    root_id: rootId,
+    tool_call_id: toolCallId,
+    turn_count_hint: turnCountHint
+  };
+  return { recordId, payload: new TextEncoder().encode(JSON.stringify(record)) };
+}
+var TOOL_CALL_ID_CONTEXT_KEY = "toolCallId";
+function fabricTracing(options = {}) {
+  assertValidTraceOptions(options);
+  const edgeSubject = options.edgeSubject === void 0 ? DEFAULT_EDGE_SUBJECT : options.edgeSubject;
+  return {
+    promptInterceptor: promptInterceptor(edgeSubject),
+    requestInterceptor,
+    heartbeatExtras: edgeSubject === null ? () => ({}) : () => {
+      const counts = traceRecordCounts();
+      return { records_published: counts.published, records_dropped: counts.dropped };
+    }
+  };
+}
+function promptInterceptor(edgeSubject) {
+  return {
+    beforePrompt(ctx) {
+      const raw = ctx.context[TOOL_CALL_ID_CONTEXT_KEY];
+      const toolCallId = typeof raw === "string" && validToolCallId(raw) ? raw : null;
+      const plan = { ...mintLineage(), toolCallId };
+      return {
+        fields: { [THREAD_ID_FIELD]: plan.threadId, [ROOT_ID_FIELD]: plan.rootId },
+        state: plan
+      };
+    },
+    async beforePublish(ctx, extras) {
+      const plan = extras?.state;
+      if (edgeSubject === null || plan === void 0) return;
+      await publishEdge(ctx, edgeSubject, plan);
+    }
+  };
+}
+function mintLineage() {
+  const threadId = randomThreadId();
+  const ambient = activeTrace();
+  if (ambient === void 0) {
+    return { threadId, parentId: null, rootId: threadId, turnCountHint: 0 };
+  }
+  return {
+    threadId,
+    parentId: ambient.threadId,
+    rootId: ambient.rootId,
+    turnCountHint: ambient.turnCountHint
+  };
+}
+async function publishEdge(ctx, subject, plan) {
+  if (!ctx.identity.canSign) {
+    warnEdgesUnsigned(ctx.connection);
+    countTraceRecordDropped();
+    return;
+  }
+  try {
+    const agent = await ctx.identity.selfId();
+    const record = buildEdgeRecord(
+      agent,
+      plan.threadId,
+      plan.parentId,
+      plan.rootId,
+      plan.toolCallId,
+      plan.turnCountHint
+    );
+    await ctx.identity.publishSigned(subject, record.payload, { nonce: record.recordId });
+    countTraceRecordPublished();
+  } catch (err) {
+    countTraceRecordDropped();
+    console.warn(`@synadia-ai/agent-fabric: failed to publish edge record on ${subject}`, err);
+  }
+}
+var warnedUnsigned = /* @__PURE__ */ new WeakSet();
+function warnEdgesUnsigned(nc) {
+  if (warnedUnsigned.has(nc)) return;
+  warnedUnsigned.add(nc);
+  console.warn(
+    "@synadia-ai/agent-fabric: tracing is enabled but no identity signer is configured; edge records are not published (consumers ignore unsigned records). Pass identity: { signer } to sign them."
+  );
+}
+var requestInterceptor = {
+  async aroundRequest(ctx, next) {
+    await bindActiveTrace(scopeFor(ctx.envelope.extras ?? {}), next);
+  }
+};
+var HALF_LINEAGE_PAIR = "envelope `thread_id` and `root_id` must be given together";
+function scopeFor(extras) {
+  const threadId = lineageField(extras, THREAD_ID_FIELD);
+  const rootId = lineageField(extras, ROOT_ID_FIELD);
+  if (threadId === void 0 !== (rootId === void 0)) {
+    throw new RequestRejectedError(400, HALF_LINEAGE_PAIR);
+  }
+  if (threadId !== void 0 && rootId !== void 0) {
+    return { threadId, rootId, turnCountHint: 0 };
+  }
+  const minted = randomThreadId();
+  return { threadId: minted, rootId: minted, turnCountHint: 0 };
+}
+function lineageField(extras, wireName) {
+  const value = Object.hasOwn(extras, wireName) ? extras[wireName] : void 0;
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string") {
+    throw new RequestRejectedError(400, `envelope \`${wireName}\` must be a string`);
+  }
+  if (value === "") return void 0;
+  if (!isThreadId(value)) {
+    throw new RequestRejectedError(
+      400,
+      `envelope \`${wireName}\` must be ${THREAD_ID_HEX_LEN} lowercase hex characters`
+    );
+  }
+  return value;
+}
+
+// src/caller.ts
+var CALLER_INBOX_PREFIX = "_INBOX.agents";
+var CANNOT_ANSWER = "The caller is a command line and cannot answer; continue with your best judgement.";
+var DEFAULT_DISCOVER_TIMEOUT_MS = 1e3;
+var NATS_URL_VAR = "NATS_URL";
+var NATS_CREDS_VAR = "NATS_CREDS";
+var FabricCallerError = class extends Error {
+  constructor(reason, message2) {
+    super(message2);
+    this.reason = reason;
+    this.name = "FabricCallerError";
+  }
+  reason;
+};
+var CallerStream = class {
+  #inner;
+  #sink;
+  constructor(inner, sink) {
+    this.#inner = inner;
+    this.#sink = sink;
+  }
+  /** The subject the prompt is published to. */
+  get subject() {
+    return this.#inner.subject;
+  }
+  /** Stop the stream, as `PromptStream.cancel()`. */
+  cancel() {
+    this.#sink.reject(notSent("it was cancelled"));
+    this.#inner.cancel();
+  }
+  async *[Symbol.asyncIterator]() {
+    try {
+      for await (const msg of this.#inner) yield msg;
+    } catch (err) {
+      this.#sink.reject(err);
+      throw err;
+    } finally {
+      this.#sink.reject(notSent("its stream ended first"));
+    }
+  }
+};
+function notSent(why) {
+  return new FabricCallerError("not-sent", `the prompt never went out, so it has no root: ${why}`);
+}
+var ROOT_SINK_KEY = "agentFabricCallerRootSink";
+function rootDeferred() {
+  let settled = false;
+  let resolve;
+  let reject;
+  const rootId = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  rootId.catch(() => {
+  });
+  const once = (fn) => (v) => {
+    if (settled) return;
+    settled = true;
+    fn(v);
+  };
+  return { rootId, sink: { resolve: once(resolve), reject: once(reject) } };
+}
+async function fabricCaller(options) {
+  const creds = options.creds;
+  if (typeof creds !== "string" || creds.length === 0) {
+    throw new FabricCallerError(
+      "config",
+      `no creds file: pass creds, or set ${NATS_CREDS_VAR} to the creds file the console gave you`
+    );
+  }
+  const url = options.url ?? process.env[NATS_URL_VAR];
+  if (url === void 0 || url.length === 0) {
+    throw new FabricCallerError(
+      "config",
+      `no server URL: pass url, or set ${NATS_URL_VAR} to the URL the console showed next to your creds file`
+    );
+  }
+  const tracing = fabricTracing(
+    options.edgeSubject !== void 0 ? { edgeSubject: options.edgeSubject } : {}
+  );
+  if (options.name !== void 0) {
+    try {
+      assertValidSenderName(options.name);
+    } catch (err) {
+      throw new FabricCallerError("config", `name: ${errorMessage(err)}`);
+    }
+  }
+  let bundle;
+  try {
+    bundle = await resolveNatsConnectionBundle({ url, creds }, { identity: "signed" });
+  } catch (err) {
+    throw new FabricCallerError("config", `creds file ${creds}: ${errorMessage(err)}`);
+  }
+  let nc;
+  try {
+    nc = await connect(
+      withAgentReconnectDefaults({
+        ...bundle.connectionOptions,
+        inboxPrefix: CALLER_INBOX_PREFIX,
+        ...options.name !== void 0 ? { name: options.name } : {},
+        // A caller is short-lived: a wrong URL fails now, naming the URL,
+        // instead of retrying forever before the first connection.
+        waitOnFirstConnect: false
+      })
+    );
+  } catch (err) {
+    bundle.wipe();
+    throw new FabricCallerError("connect", `could not connect to ${url}: ${errorMessage(err)}`);
+  }
+  let agents;
+  try {
+    agents = new Agents({
+      nc,
+      identity: {
+        signer: bundle.signer,
+        ...options.name !== void 0 ? { name: options.name } : {}
+      },
+      interceptors: [rootCapturing(tracing.promptInterceptor)]
+    });
+  } catch (err) {
+    await nc.close();
+    bundle.wipe();
+    throw err;
+  }
+  try {
+    await agents.selfId();
+  } catch (err) {
+    await agents.close();
+    await nc.close();
+    bundle.wipe();
+    throw new FabricCallerError(
+      "identity",
+      `the server at ${url} would not tell this creds file's identity, which signing needs: ${errorMessage(err)}`
+    );
+  }
+  const list = (opts = {}) => agents.discover({ timeoutMs: opts.timeoutMs ?? DEFAULT_DISCOVER_TIMEOUT_MS });
+  const find = async (who, opts = {}) => pickAgent(await list(opts), who);
+  const prompt2 = async (who, text, promptOptions = {}) => {
+    const target = typeof who === "string" ? await find(who) : who;
+    const { sink, rootId } = rootDeferred();
+    let inner;
+    try {
+      inner = await target.prompt(text, {
+        ...promptOptions,
+        context: { ...promptOptions.context ?? {}, [ROOT_SINK_KEY]: sink }
+      });
+    } catch (err) {
+      sink.reject(err);
+      throw err;
+    }
+    return { stream: new CallerStream(inner, sink), rootId };
+  };
+  const ask = async (who, text, askOptions = {}) => {
+    const { onQuery, ...promptOptions } = askOptions;
+    const { stream, rootId } = await prompt2(who, text, promptOptions);
+    let reply = "";
+    for await (const msg of stream) {
+      if (msg.type === "response") reply += msg.text;
+      else if (msg.type === "query") {
+        const answer = onQuery !== void 0 ? await onQuery(msg) : "";
+        await msg.reply(answer.trim() === "" ? CANNOT_ANSWER : answer);
+      }
+    }
+    return { text: reply, rootId: await rootId };
+  };
+  let closed = false;
+  const close = async () => {
+    if (closed) return;
+    closed = true;
+    try {
+      await agents.close();
+      await nc.close();
+    } finally {
+      bundle.wipe();
+    }
+  };
+  return { agents, url, list, find, prompt: prompt2, ask, close };
+}
+function pickAgent(found, who) {
+  const byAddress = found.find((a) => a.promptSubject === who);
+  if (byAddress !== void 0) return byAddress;
+  const ofKind = distinctAddresses(found.filter((a) => a.agent === who));
+  if (ofKind.length === 1) return ofKind[0];
+  if (ofKind.length > 1) {
+    throw new FabricCallerError(
+      "ambiguous",
+      `${ofKind.length} agents of kind "${who}": ${ofKind.map((a) => a.promptSubject).join(", ")}; name one by its address`
+    );
+  }
+  const there = distinctAddresses(found).map((a) => a.promptSubject).join(", ");
+  throw new FabricCallerError("not-found", `no agent "${who}"; there: ${there || "nobody"}`);
+}
+function distinctAddresses(agents) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const a of agents) if (!seen.has(a.promptSubject)) seen.set(a.promptSubject, a);
+  return [...seen.values()];
+}
+function rootCapturing(inner) {
+  return {
+    async beforePrompt(ctx) {
+      const sink = ctx.context[ROOT_SINK_KEY];
+      let extras;
+      try {
+        extras = await inner.beforePrompt(ctx);
+      } catch (err) {
+        sink?.reject(err);
+        throw err;
+      }
+      const root = extras?.fields?.[ROOT_ID_FIELD];
+      if (typeof root === "string") sink?.resolve(root);
+      else sink?.reject(notSent("tracing minted no root"));
+      return extras;
+    },
+    async beforePublish(ctx, extras) {
+      await inner.beforePublish?.(ctx, extras);
+    }
+  };
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/scratchpad.ts
+var REFERENCE_RE = /sp-(?:ref|r1):[A-Za-z0-9_-]+/g;
+function findReferences(text) {
+  return text.match(REFERENCE_RE) ?? [];
+}
+
+// src/command.ts
+var EXIT_OK = 0;
+var EXIT_FAILED = 1;
+var EXIT_USAGE = 2;
+var DEFAULT_TIMEOUT_S = 600;
+var USAGE = `usage: agent-fabric agents [options]
+       agent-fabric prompt <address or kind> "<text>" [options]
+
+List the agents on the Synadia Agent Fabric, or prompt one, with the creds
+file the console gave you. The reply streams to stdout; the server's URL,
+the agent, the task's root id and a ScratchPad reference go to stderr. A
+question the agent asks is printed on stderr and answered from stdin.
+
+options:
+  --creds <file>    the creds file (default: $${NATS_CREDS_VAR})
+  --url <url>       the URL the console showed next to your creds file
+                    (default: $${NATS_URL_VAR})
+  --timeout <s>     how long to wait for the whole reply, in seconds
+                    (default: ${DEFAULT_TIMEOUT_S})
+  --json            one JSON object on stdout instead of the stream
+  -h, --help        this help
+  --                the rest is the text, even what starts with -
+
+exit codes: 0 done, 1 no such agent or a refused prompt, 2 usage`;
+function parseCommand(argv) {
+  const positional = [];
+  let creds;
+  let url;
+  let timeoutS = DEFAULT_TIMEOUT_S;
+  let json = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--") {
+      positional.push(...argv.slice(i + 1));
+      break;
+    }
+    const [flag, inline] = arg.startsWith("--") ? splitFlag(arg) : [arg, void 0];
+    const value = () => inline ?? argv[++i];
+    switch (flag) {
+      case "-h":
+      case "--help":
+        return { kind: "help" };
+      case "--json":
+        json = true;
+        break;
+      case "--creds":
+      case "--url":
+      case "--timeout": {
+        const v = value();
+        if (v === void 0 || v === "") return usage(`${flag} needs a value`);
+        if (flag === "--creds") creds = v;
+        else if (flag === "--url") url = v;
+        else {
+          const n = Number(v);
+          if (!Number.isFinite(n) || n <= 0) {
+            return usage(`--timeout must be a positive number of seconds, not "${v}"`);
+          }
+          timeoutS = n;
+        }
+        break;
+      }
+      default:
+        if (arg.startsWith("-") && arg !== "-") return usage(`unknown option ${arg}`);
+        positional.push(arg);
+    }
+  }
+  const [sub, ...rest] = positional;
+  const common = {
+    ...creds !== void 0 ? { creds } : {},
+    ...url !== void 0 ? { url } : {},
+    timeoutS,
+    json
+  };
+  if (sub === void 0) return usage("name a command: agents or prompt");
+  if (sub === "help") return { kind: "help" };
+  if (sub === "agents") {
+    if (rest.length > 0) return usage(`agents takes no arguments, not "${rest.join(" ")}"`);
+    return { kind: "agents", ...common };
+  }
+  if (sub === "prompt") {
+    const [who, ...words] = rest;
+    const text = words.join(" ");
+    if (who === void 0 || text.length === 0) {
+      return usage('prompt needs an agent and a text: prompt <address or kind> "<text>"');
+    }
+    return { kind: "prompt", who, text, ...common };
+  }
+  return usage(`unknown command "${sub}"`);
+}
+function splitFlag(arg) {
+  const eq = arg.indexOf("=");
+  return eq < 0 ? [arg, void 0] : [arg.slice(0, eq), arg.slice(eq + 1)];
+}
+function usage(message2) {
+  return { kind: "usage", message: message2 };
+}
+async function runCommand(argv, io) {
+  const parsed = parseCommand(argv);
+  if (parsed.kind === "help") {
+    io.out(`${USAGE}
+`);
+    return EXIT_OK;
+  }
+  if (parsed.kind === "usage") {
+    io.err(`agent-fabric: ${parsed.message}
+
+${USAGE}
+`);
+    return EXIT_USAGE;
+  }
+  const creds = parsed.creds ?? io.env[NATS_CREDS_VAR] ?? "";
+  const url = parsed.url ?? io.env[NATS_URL_VAR] ?? "";
+  if (creds === "") {
+    io.err(`agent-fabric: no creds file: pass --creds, or set ${NATS_CREDS_VAR}
+`);
+    return EXIT_USAGE;
+  }
+  if (url === "") {
+    io.err(
+      `agent-fabric: no server URL: pass --url, or set ${NATS_URL_VAR} to the URL the console showed next to your creds file
+`
+    );
+    return EXIT_USAGE;
+  }
+  io.err(`url ${url}
+`);
+  let caller;
+  try {
+    caller = await fabricCaller({ creds, url, name: "agent-fabric" });
+  } catch (err) {
+    io.err(`agent-fabric: ${message(err)}
+`);
+    return err instanceof FabricCallerError && err.reason === "config" ? EXIT_USAGE : EXIT_FAILED;
+  }
+  try {
+    if (parsed.kind === "agents") return await listAgents(caller, parsed.json, io);
+    return await prompt(caller, parsed.who, parsed.text, parsed, io);
+  } catch (err) {
+    if (err instanceof FabricCallerError) {
+      io.err(`agent-fabric: ${err.message}
+`);
+    } else {
+      io.err(`agent-fabric: no reply: ${message(err)}
+`);
+    }
+    return EXIT_FAILED;
+  } finally {
+    await caller.close();
+  }
+}
+function agentLine(a) {
+  return {
+    address: a.promptSubject,
+    kind: a.agent,
+    identity: a.identity ?? null,
+    verified: a.idSigVerified,
+    description: a.description
+  };
+}
+async function listAgents(caller, json, io) {
+  const seen = /* @__PURE__ */ new Set();
+  const lines = [];
+  for (const a of await caller.list()) {
+    if (seen.has(a.promptSubject)) continue;
+    seen.add(a.promptSubject);
+    lines.push(agentLine(a));
+  }
+  lines.sort((x, y) => x.address < y.address ? -1 : x.address > y.address ? 1 : 0);
+  if (json) {
+    io.out(`${JSON.stringify(lines)}
+`);
+    return EXIT_OK;
+  }
+  if (lines.length === 0) io.err("no agents\n");
+  for (const l of lines) io.out(`${l.address}	${l.kind}	${describeIdentity(l)}
+`);
+  return EXIT_OK;
+}
+function describeIdentity(l) {
+  if (l.identity === null) return "agent identity: none";
+  return l.verified ? `agent ${l.identity}, verified` : `agent ${l.identity}`;
+}
+async function prompt(caller, who, text, opts, io) {
+  const target = await caller.find(who);
+  io.err(`\u2192 ${target.promptSubject} (${describeIdentity(agentLine(target))})
+`);
+  const { stream, rootId } = await caller.prompt(target, text, {
+    maxWaitMs: Math.round(opts.timeoutS * 1e3)
+  });
+  rootId.then(
+    (root2) => io.err(`root ${root2}
+`),
+    () => {
+    }
+  );
+  let reply = "";
+  for await (const msg of stream) {
+    if (msg.type === "response") {
+      reply += msg.text;
+      if (!opts.json) io.out(msg.text);
+    } else if (msg.type === "query") {
+      io.err(`? ${msg.prompt}
+`);
+      const answer = await io.readLine();
+      await msg.reply(answer === null || answer.trim() === "" ? CANNOT_ANSWER : answer);
+    }
+  }
+  const root = await rootId;
+  const references = findReferences(reply);
+  if (opts.json) {
+    io.out(`${JSON.stringify({ root, text: reply, references })}
+`);
+  } else {
+    io.out("\n");
+  }
+  const last = references.at(-1);
+  if (last !== void 0) io.err(`reference: ${last}
+`);
+  return EXIT_OK;
+}
+function message(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/cli.ts
+function processIO() {
+  let lines;
+  return {
+    out: (text) => void process.stdout.write(text),
+    err: (text) => void process.stderr.write(text),
+    async readLine() {
+      lines ??= createInterface({ input: process.stdin, terminal: false })[Symbol.asyncIterator]();
+      const next = await lines.next();
+      return next.done === true ? null : next.value;
+    },
+    env: process.env
+  };
+}
+function main() {
+  return runCommand(process.argv.slice(2), processIO());
+}
+main().then(
+  (code) => {
+    process.exitCode = code;
+    process.stdin.destroy();
+  },
+  (err) => {
+    process.stderr.write(`agent-fabric: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exitCode = 1;
+    process.stdin.destroy();
+  }
+);
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map