envio 3.12.1 → 3.13.0-alpha.0

package/src/Supervisor.res.mjs

@@ -0,0 +1,325 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Env from "./Env.res.mjs";
+import * as Tui from "./tui/Tui.res.mjs";
+import * as Utils from "./Utils.res.mjs";
+import * as Config from "./Config.res.mjs";
+import * as Server from "./Server.res.mjs";
+import * as Worker from "./Worker.res.mjs";
+import * as ChainId from "./ChainId.res.mjs";
+import * as Logging from "./Logging.res.mjs";
+import * as Metrics from "./Metrics.res.mjs";
+import * as Process from "process";
+import * as ChainMap from "./ChainMap.res.mjs";
+import * as PgStorage from "./PgStorage.res.mjs";
+import * as Performance from "./bindings/Performance.res.mjs";
+import * as Persistence from "./Persistence.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Child_process from "child_process";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+
+function plan(chainIds, maxConnections) {
+  let workerCount = Primitive_int.min(chainIds.length, maxConnections / 2 | 0);
+  if (workerCount < 2) {
+    return;
+  }
+  let evenShare = Primitive_int.div(maxConnections, workerCount);
+  let remainder = Primitive_int.mod_(maxConnections, workerCount);
+  return Stdlib_Array.fromInitializer(workerCount, workerIndex => ({
+    chainIds: chainIds.filter((param, dealIndex) => {
+      let position = Primitive_int.mod_(dealIndex, workerCount);
+      let isReversePass = Primitive_int.div(dealIndex, workerCount) % 2 === 1;
+      return (
+        isReversePass ? (workerCount - 1 | 0) - position | 0 : position
+      ) === workerIndex;
+    }),
+    maxConnections: evenShare + (
+      workerIndex < remainder ? 1 : 0
+    ) | 0
+  }));
+}
+
+function planForRun(config, maxConnectionsOpt) {
+  let maxConnections = maxConnectionsOpt !== undefined ? maxConnectionsOpt : Env.Db.maxConnections;
+  if (config.isolated || !Config.isPerChain(config)) {
+    return;
+  } else {
+    return plan(ChainMap.values(config.chainMap).map(chain => chain.id), maxConnections);
+  }
+}
+
+function name(worker) {
+  return worker.chainIds.map(ChainId.toString).join(";");
+}
+
+function label(worker) {
+  return `[chain ` + name(worker) + `]`;
+}
+
+function logFilePath(workerIndex, pathOpt) {
+  let path = pathOpt !== undefined ? pathOpt : Env.logFilePath;
+  let suffix = `.worker-` + workerIndex.toString();
+  let dot = path.lastIndexOf(".");
+  if (dot > path.lastIndexOf("/")) {
+    return path.slice(0, dot) + suffix + path.slice(dot, path.length);
+  } else {
+    return path + suffix;
+  }
+}
+
+function readLines(onLine) {
+  let pending = {
+    contents: ""
+  };
+  let read = chunk => {
+    let parts = (pending.contents + chunk).split("\n");
+    pending.contents = Stdlib_Option.getOr(parts.pop(), "");
+    parts.forEach(onLine);
+  };
+  let flush = () => {
+    let line = pending.contents;
+    if (line === "") {
+      return;
+    }
+    pending.contents = "";
+    onLine(line);
+  };
+  return [
+    read,
+    flush
+  ];
+}
+
+function fork(worker, workerIndex, holdRealtime, entryPathOpt, pipeOutputOpt, onOutputOpt) {
+  let entryPath = entryPathOpt !== undefined ? entryPathOpt : process.argv[1];
+  let pipeOutput = pipeOutputOpt !== undefined ? pipeOutputOpt : false;
+  let onOutput = onOutputOpt !== undefined ? onOutputOpt : prim => {
+      console.log(prim);
+    };
+  let env = Object.assign({}, Process.env);
+  env[Worker.envVar] = S$RescriptSchema.reverseConvertToJsonStringOrThrow({
+    chainIds: worker.chainIds,
+    holdRealtime: holdRealtime
+  }, Worker.configSchema, undefined);
+  env["ENVIO_PG_MAX_CONNECTIONS"] = worker.maxConnections.toString();
+  env["LOG_FILE"] = logFilePath(workerIndex, undefined);
+  if (pipeOutput && Stdlib_Option.getOr((process.stdout.isTTY == null) ? undefined : Primitive_option.some(process.stdout.isTTY), false)) {
+    env["FORCE_COLOR"] = "1";
+  }
+  let child = Child_process.fork(entryPath, [], {
+    env: env,
+    serialization: "advanced",
+    stdio: pipeOutput ? [
+        "inherit",
+        "pipe",
+        "pipe",
+        "ipc"
+      ] : [
+        "inherit",
+        "inherit",
+        "inherit",
+        "ipc"
+      ]
+  });
+  if (pipeOutput) {
+    [
+      child.stdout,
+      child.stderr
+    ].forEach(stream => {
+      if (stream === null) {
+        return;
+      }
+      let match = readLines(onOutput);
+      stream.setEncoding("utf8");
+      stream.on("data", match[0]);
+      stream.on("end", match[1]);
+    });
+  }
+  let running = {
+    worker: worker,
+    child: child,
+    snapshot: undefined,
+    runtime: undefined,
+    settled: false
+  };
+  child.on("message", message => {
+    running.snapshot = message.metrics;
+    running.runtime = message.runtime;
+  });
+  return running;
+}
+
+function stop(group) {
+  group.stopping = true;
+  group.running.forEach(r => {
+    r.child.kill("SIGTERM");
+  });
+}
+
+let inFlight = {
+  contents: undefined
+};
+
+function syncCache(dump) {
+  let dumping = inFlight.contents;
+  if (dumping !== undefined) {
+    return dumping;
+  }
+  let dumping$1 = dump().finally(() => {
+    inFlight.contents = undefined;
+  });
+  inFlight.contents = dumping$1;
+  return dumping$1;
+}
+
+function dumpCache(config) {
+  let storage = PgStorage.makeStorageFromEnv(config, Primitive_option.some(PgStorage.makeClient(1)), undefined, undefined);
+  return storage.dumpEffectCache().finally(() => {
+    storage.close();
+  });
+}
+
+async function awaitExit(group) {
+  let failed = {
+    contents: false
+  };
+  let alive = {
+    contents: group.running.length
+  };
+  await new Promise((resolve, param) => {
+    let onGone = (r, failure) => {
+      if (!r.settled) {
+        r.settled = true;
+        if (failure) {
+          failed.contents = true;
+          if (!group.stopping) {
+            stop(group);
+          }
+        }
+        alive.contents = alive.contents - 1 | 0;
+        if (alive.contents === 0) {
+          return resolve();
+        } else {
+          return;
+        }
+      }
+    };
+    group.running.forEach(r => {
+      r.child.on("exit", (code, _signal) => onGone(r, !group.stopping && (
+        code === null ? undefined : Primitive_option.some(code)
+      ) !== 0));
+      r.child.on("error", exn => {
+        Logging.errorWithExn(exn, label(r.worker) + ` failed to start`);
+        onGone(r, true);
+      });
+    });
+  });
+  if (failed.contents) {
+    Stdlib_JsError.throwWithMessage("An indexer process exited with a failure. Stopped the others.");
+  }
+  if (group.stopping) {
+    return "Stopped";
+  } else {
+    return "Finished";
+  }
+}
+
+function isRunAtHead(snapshots, workerCount) {
+  if (snapshots.length === workerCount) {
+    return snapshots.every(snapshot => snapshot.hasArrivedAtHead);
+  } else {
+    return false;
+  }
+}
+
+async function run(config, workers, reset) {
+  let persistence = PgStorage.makePersistenceFromConfig(config, undefined);
+  await Persistence.initForRun(persistence, config, reset, config.isDev, false);
+  await persistence.storage.close();
+  let startTime = new Date();
+  let startTimeRef = Performance.now();
+  Logging.info(`Splitting ` + ChainMap.values(config.chainMap).length.toString() + ` chains across ` + workers.length.toString() + ` processes, from a budget of ` + Env.Db.maxConnections.toString() + ` database connections.`);
+  let shouldUseTui = Tui.shouldUse(undefined);
+  let holdRealtime = Persistence.getInitializedState(persistence).chains.some(chain => Stdlib_Option.isNone(chain.timestampCaughtUpToHeadOrEndblock));
+  let group = {
+    running: workers.map((worker, workerIndex) => fork(worker, workerIndex, holdRealtime, undefined, shouldUseTui, undefined)),
+    stopping: false
+  };
+  let reported = () => Stdlib_Array.filterMap(group.running, r => r.snapshot);
+  let merge = snapshots => Metrics.merge(snapshots, startTime, new Date(), Performance.secondsSince(startTimeRef));
+  Server.startServer(() => {
+    let snapshots = reported();
+    if (snapshots.length !== 0) {
+      return merge(snapshots);
+    }
+  }, Utils.EnvioPackage.value.version, () => syncCache(() => dumpCache(config)), () => Metrics.renderRuntime(Stdlib_Array.filterMap(group.running, r => Stdlib_Option.map(r.runtime, runtime => [
+    `worker="` + name(r.worker) + `"`,
+    runtime
+  ]))), config.isDev);
+  let releaseCheck = {
+    contents: undefined
+  };
+  let stopReleaseCheck = () => {
+    Stdlib_Option.forEach(releaseCheck.contents, prim => {
+      clearInterval(prim);
+    });
+    releaseCheck.contents = undefined;
+  };
+  if (holdRealtime) {
+    releaseCheck.contents = Primitive_option.some(setInterval(() => {
+      if (isRunAtHead(reported(), group.running.length)) {
+        stopReleaseCheck();
+        group.running.forEach(r => {
+          r.child.send("release-realtime");
+        });
+        return Logging.info("Every chain has reached the head. Switching the run to realtime.");
+      }
+    }, 500));
+  }
+  if (shouldUseTui) {
+    Tui.start(config, () => merge(reported()));
+  }
+  process.on("SIGTERM", () => stop(group));
+  process.on("SIGINT", () => stop(group));
+  let outcome = await awaitExit(group);
+  stopReleaseCheck();
+  if (outcome === "Finished") {
+    if (shouldUseTui) {
+      process.on("SIGTERM", () => {
+        Process.exit(0);
+      });
+      process.on("SIGINT", () => {
+        Process.exit(0);
+      });
+    } else {
+      Logging.info("Exiting with success");
+      Process.exit(0);
+    }
+    return;
+  }
+  Process.exit(0);
+}
+
+let minConnectionsPerWorker = 2;
+
+export {
+  minConnectionsPerWorker,
+  plan,
+  planForRun,
+  name,
+  label,
+  logFilePath,
+  readLines,
+  fork,
+  stop,
+  syncCache,
+  dumpCache,
+  awaitExit,
+  isRunAtHead,
+  run,
+}
+/* Env Not a pure module */

package/src/TestIndexer.res.mjs

@@ -639,7 +639,7 @@ function createTestIndexer() {
       };
       try {
         await new Promise((resolve, reject) => {
-          let indexerState = IndexerState.makeFromDbState(runConfig, persistence, initialState, registrationsByChainId, undefined, undefined, exitAfterFirstEventBlock, undefined, undefined, errHandler => {
+          let indexerState = IndexerState.makeFromDbState(runConfig, persistence, initialState, registrationsByChainId, undefined, undefined, exitAfterFirstEventBlock, undefined, undefined, undefined, errHandler => {
             ErrorHandling.log(errHandler);
             reject(Utils.prettifyExn(errHandler.exn));
           }, () => resolve());

package/src/Worker.res

@@ -0,0 +1,95 @@
+// The worker side of a supervised run: a process the supervisor forked to drive
+// a subset of the chains. It has no server and no TUI of its own — it reports
+// through the IPC channel, and the supervisor is the one operational surface.
+
+// Set by a supervisor in the environment of the workers it forks. Internal:
+// it counts only together with the fork's own channel, so a copy left in a
+// shell starts nothing, and an indexer a user starts themselves takes every
+// path it takes today.
+let envVar = "ENVIO_INTERNAL_WORKER"
+
+// What the supervisor decided about this worker, handed over in the spawn
+// environment rather than over the channel: it is settled before the process
+// starts, and the worker needs it before it can load its own config.
+type config = {
+  chainIds: array<ChainId.t>,
+  // The chains this worker drives may reach the head while chains in another
+  // process are still backfilling, and an indexer goes realtime as a whole or
+  // not at all. Cleared by the supervisor's `ReleaseRealtime`.
+  holdRealtime: bool,
+}
+
+let configSchema = S.object((s): config => {
+  chainIds: s.field("chainIds", S.array(ChainId.schema)),
+  holdRealtime: s.fieldOr("holdRealtime", S.bool, false),
+})
+
+// Read as this module loads, which is before anything that could catch a bare
+// schema error and say where it came from.
+let detect = (~env: dict<string>, ~hasChannel) =>
+  switch (hasChannel, env->Dict.get(envVar)) {
+  | (true, Some(json)) =>
+    switch json->S.parseJsonStringOrThrow(configSchema) {
+    | config => Some(config)
+    | exception S.Raised(error) =>
+      JsError.throwWithMessage(
+        `Invalid ${envVar}: ${error->S.Error.message}. It is set by an indexer supervisor for the processes it forks, and isn't meant to be set by hand.`,
+      )
+    }
+  | _ => None
+  }
+
+let config = detect(
+  ~env=NodeJs.Process.process.env,
+  ~hasChannel=NodeJs.Process.channel->Nullable.toOption->Option.isSome,
+)
+
+let isEnabled = config->Option.isSome
+
+@tag("kind")
+type parentMessage =
+  // Every chain in the run has reached the head, so this worker may enter the
+  // reorg threshold and switch to realtime with the rest of them.
+  | @as("release-realtime") ReleaseRealtime
+
+@tag("kind")
+type workerMessage =
+  | @as("snapshot") Snapshot({metrics: Metrics.t, runtime: Metrics.runtimeSample})
+
+// How often a worker reports. Matches the TUI's own refresh, so the supervised
+// display moves at the same rate an unsplit run's does.
+%%private(let snapshotIntervalMillis = 500)
+
+// The supervisor is the one that stops a worker, and the one whose absence
+// ends it. A terminal's interrupt reaches the whole group at once, so the
+// worker leaves it to the supervisor, which stops every worker in turn; without
+// that, a worker gone on its own would read as a failure to the supervisor
+// still deciding what the interrupt meant. A supervisor that dies can't tear
+// the group down, so losing the channel is what ends the worker then.
+let bindToSupervisor = () => {
+  NodeJs.Process.onSignal("SIGINT", () => ())
+  NodeJs.Process.onDisconnect(() => {
+    Logging.error("The indexer supervisor is gone. Stopping this chain's process.")
+    NodeJs.process->NodeJs.exitWithCode(Failure)
+  })
+}
+
+%%private(let send = (message: workerMessage) => NodeJs.Process.sendToParent(message)->ignore)
+
+// Reports this process's chains and its own runtime for as long as it runs, so
+// the supervisor can merge every worker's into the one snapshot the run serves,
+// and listens for the one decision the supervisor makes on the run's behalf.
+// Does nothing in a process nobody forked.
+let bindRun = (~getMetrics: unit => Metrics.t, ~onReleaseRealtime: unit => unit) =>
+  if isEnabled {
+    Metrics.startRuntimeCollectors()
+    let _intervalId = setInterval(
+      () => send(Snapshot({metrics: getMetrics(), runtime: Metrics.sampleRuntime()})),
+      snapshotIntervalMillis,
+    )
+    NodeJs.Process.onMessage((message: parentMessage) =>
+      switch message {
+      | ReleaseRealtime => onReleaseRealtime()
+      }
+    )
+  }

package/src/Worker.res.mjs

@@ -0,0 +1,80 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as ChainId from "./ChainId.res.mjs";
+import * as Logging from "./Logging.res.mjs";
+import * as Metrics from "./Metrics.res.mjs";
+import * as Process from "process";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+
+let envVar = "ENVIO_INTERNAL_WORKER";
+
+let configSchema = S$RescriptSchema.object(s => ({
+  chainIds: s.f("chainIds", S$RescriptSchema.array(ChainId.schema)),
+  holdRealtime: s.fieldOr("holdRealtime", S$RescriptSchema.bool, false)
+}));
+
+function detect(env, hasChannel) {
+  let match = env[envVar];
+  if (!hasChannel) {
+    return;
+  }
+  if (match === undefined) {
+    return;
+  }
+  let config;
+  try {
+    config = S$RescriptSchema.parseJsonStringOrThrow(match, configSchema);
+  } catch (raw_error) {
+    let error = Primitive_exceptions.internalToException(raw_error);
+    if (error.RE_EXN_ID === S$RescriptSchema.Raised) {
+      return Stdlib_JsError.throwWithMessage(`Invalid ` + envVar + `: ` + S$RescriptSchema.$$Error.message(error._1) + `. It is set by an indexer supervisor for the processes it forks, and isn't meant to be set by hand.`);
+    }
+    throw error;
+  }
+  return config;
+}
+
+let config = detect(Process.env, Stdlib_Option.isSome(Primitive_option.fromNullable(process.channel)));
+
+let isEnabled = Stdlib_Option.isSome(config);
+
+function bindToSupervisor() {
+  process.on("SIGINT", () => {});
+  process.on("disconnect", () => {
+    Logging.error("The indexer supervisor is gone. Stopping this chain's process.");
+    Process.exit(1);
+  });
+}
+
+function bindRun(getMetrics, onReleaseRealtime) {
+  if (isEnabled) {
+    Metrics.startRuntimeCollectors();
+    setInterval(() => {
+      let message_0 = getMetrics();
+      let message_1 = Metrics.sampleRuntime();
+      let message = {
+        kind: "snapshot",
+        metrics: message_0,
+        runtime: message_1
+      };
+      process.send(message);
+    }, 500);
+    process.on("message", message => onReleaseRealtime());
+    return;
+  }
+}
+
+export {
+  envVar,
+  configSchema,
+  detect,
+  config,
+  isEnabled,
+  bindToSupervisor,
+  bindRun,
+}
+/* configSchema Not a pure module */

package/src/bindings/NodeJs.res

@@ -64,6 +64,21 @@ module Process = {
   @module("process") external version: string = "version"
   @module("process")
   external getActiveResourcesInfo: unit => array<string> = "getActiveResourcesInfo"
+
+  // Only a process forked with an IPC channel has these. Called through
+  // `process` rather than off a namespace import, which would drop the
+  // receiver Node's own implementations read.
+  @val @scope("process") external sendToParent: 'msg => bool = "send"
+  @val @scope("process")
+  external onMessage: (@as("message") _, 'msg => unit) => unit = "on"
+  @val @scope("process") external onSignal: (string, unit => unit) => unit = "on"
+  // Present only in a process forked with an IPC channel.
+  @val @scope("process") external channel: Nullable.t<unknown> = "channel"
+  @val @scope("process")
+  external onDisconnect: (@as("disconnect") _, unit => unit) => unit = "on"
+  @val @scope("process") external argv: array<string> = "argv"
+  @val @scope("process")
+  external emitMessage: (@as("message") _, 'msg) => bool = "emit"
 }
 
 module Buffer = {
@@ -141,6 +156,32 @@ module ChildProcess = {
 
   @module("child_process")
   external execWithOptions: (string, execOptions, callback) => unit = "exec"
+
+  type child
+  type forkOptions = {
+    cwd?: string,
+    env?: dict<string>,
+    // "advanced" uses the structured clone algorithm, so a message keeps the
+    // Date values a metrics snapshot carries instead of stringifying them.
+    serialization?: string,
+    stdio?: array<string>,
+  }
+  @module("child_process")
+  external fork: (string, array<string>, forkOptions) => child = "fork"
+  @send external send: (child, 'msg) => bool = "send"
+  @send external onMessage: (child, @as("message") _, 'msg => unit) => unit = "on"
+  @send
+  external onExit: (child, @as("exit") _, (Null.t<int>, Null.t<string>) => unit) => unit = "on"
+  @send external onChildError: (child, @as("error") _, exn => unit) => unit = "on"
+  @send external kill: (child, string) => bool = "kill"
+
+  // Present only for a stdio slot the parent asked to pipe.
+  type stdioStream
+  @get external stdout: child => Null.t<stdioStream> = "stdout"
+  @get external stderr: child => Null.t<stdioStream> = "stderr"
+  @send external setEncoding: (stdioStream, string) => unit = "setEncoding"
+  @send external onData: (stdioStream, @as("data") _, string => unit) => unit = "on"
+  @send external onEnd: (stdioStream, @as("end") _, unit => unit) => unit = "on"
 }
 
 module Url = {

package/src/db/InternalTable.res

@@ -344,7 +344,14 @@ VALUES ${valuesRows->Array.joinUnsafe(",\n       ")};`,
     let setClauses = Array.mapWithIndex(metaFields, (field, index) => {
       let fieldName = (field :> string)
       let paramIndex = index + 2 // +2 because $1 is for id in WHERE clause
-      `"${fieldName}" = $${Int.toString(paramIndex)}`
+      switch field {
+      // A chain that caught up never un-catches up, so a metadata write staged
+      // before `markReady` and flushed after the stamp must not clear it. The
+      // writes race: metadata is written on a throttle of its own, outside the
+      // batch the finalization flushes.
+      | #ready_at => `"${fieldName}" = COALESCE($${Int.toString(paramIndex)}, "${fieldName}")`
+      | _ => `"${fieldName}" = $${Int.toString(paramIndex)}`
+      }
     })
 
     `UPDATE "${pgSchema}"."${table.tableName}"

package/src/db/InternalTable.res.mjs

@@ -246,7 +246,11 @@ let metaFields = [
 function makeMetaFieldsUpdateQuery(pgSchema) {
   let setClauses = metaFields.map((field, index) => {
     let paramIndex = index + 2 | 0;
-    return `"` + field + `" = $` + paramIndex.toString();
+    if (field === "ready_at") {
+      return `"` + field + `" = COALESCE($` + paramIndex.toString() + `, "` + field + `")`;
+    } else {
+      return `"` + field + `" = $` + paramIndex.toString();
+    }
   });
   return `UPDATE "` + pgSchema + `"."` + table$2.tableName + `"
 SET ` + setClauses.join(",\n    ") + `

package/src/tui/Tui.res

@@ -248,6 +248,30 @@ module App = {
   }
 }
 
+type args = {@as("tui-off") tuiOff?: bool}
+
+type process
+@val external process: process = "process"
+@get external argv: process => 'a = "argv"
+
+type mainArgs = Yargs.parsedArgs<args>
+
+// Whether this process draws the progress display: `--tui-off` first, then
+// `ENVIO_TUI`, then whether anything is watching. A supervisor asks the same
+// question its workers would have, since it is the one drawing for the run.
+let shouldUse = (~suppressed=false) => {
+  let mainArgs: mainArgs = process->argv->Yargs.hideBin->Yargs.yargs->Yargs.argv
+  let explicitTui = switch mainArgs.tuiOff {
+  | Some(off) => Some(!off)
+  | None => Env.tuiEnvVar
+  }
+  switch (suppressed, explicitTui) {
+  | (true, _) => false
+  | (_, Some(tui)) => tui
+  | (_, None) => !Envio.isNonInteractive()
+  }
+}
+
 let start = (~config, ~getMetrics) => {
   let {rerender} = render(<App config getMetrics />)
   () => {

package/src/tui/Tui.res.mjs

@@ -3,14 +3,17 @@
 import * as Env from "../Env.res.mjs";
 import * as Ink from "./bindings/Ink.res.mjs";
 import * as Ink$1 from "ink";
+import * as Envio from "../Envio.res.mjs";
 import * as React from "react";
 import * as SyncETA from "./components/SyncETA.res.mjs";
 import * as TuiData from "./components/TuiData.res.mjs";
 import * as Messages from "./components/Messages.res.mjs";
+import Yargs from "yargs/yargs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import InkBigText from "ink-big-text";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Helpers from "yargs/helpers";
 import * as Primitive_float from "@rescript/runtime/lib/es6/Primitive_float.js";
 import * as JsxRuntime from "react/jsx-runtime";
 import * as BufferedProgressBar from "./components/BufferedProgressBar.res.mjs";
@@ -322,6 +325,20 @@ let App = {
   make: Tui$App
 };
 
+function shouldUse(suppressedOpt) {
+  let suppressed = suppressedOpt !== undefined ? suppressedOpt : false;
+  let mainArgs = Yargs(Helpers.hideBin(process.argv)).argv;
+  let off = mainArgs["tui-off"];
+  let explicitTui = off !== undefined ? !off : Env.tuiEnvVar;
+  if (suppressed) {
+    return false;
+  } else if (explicitTui !== undefined) {
+    return explicitTui;
+  } else {
+    return !Envio.isNonInteractive();
+  }
+}
+
 function start(config, getMetrics) {
   let match = Ink.render(undefined, JsxRuntime.jsx(Tui$App, {
     config: config,
@@ -339,6 +356,7 @@ export {
   EventsPerSecond,
   TotalEventsProcessed,
   App,
+  shouldUse,
   start,
 }
 /* Env Not a pure module */