@mostra/cli 0.0.0-stage → 0.2.0

package/src/run.ts

@@ -0,0 +1,387 @@
+/**
+ * The runner (INTERFACES §9, D140 item 16): reads the command line, runs one command, and owns
+ * everything commands share. stdout carries exactly one JSON value in `--json` mode (one per line
+ * for a stream), whatever happens, usage errors and crashes included; logs, progress and warnings
+ * go to stderr; the exit code comes from one table; telemetry's notice or question comes before
+ * the command's work and its events after it.
+ */
+import { spawn } from "node:child_process";
+import { resolve } from "node:path";
+import { createInterface } from "node:readline";
+import {
+  createDiagnostic,
+  type Diagnostic,
+  type MethodDefinition,
+  RpcError,
+} from "@mostra/protocol";
+import { connect, type InstanceConnection, type InstanceSummary } from "./client.ts";
+import {
+  type CommandContext,
+  type CommandDef,
+  type CommandOutcome,
+  commandName,
+} from "./command.ts";
+import { COMMANDS } from "./commands/index.ts";
+import { EXIT, exitCodeFor } from "./exit.ts";
+import { commandDefinition, commandHelp, groupHelp, topHelp, UNBOUNDED } from "./help.ts";
+import {
+  configDir,
+  type Environment,
+  embeddedHome,
+  locateRuntime,
+  readHomeMarks,
+  resolveHome,
+} from "./home.ts";
+import { globalFlags, parseCommandLine } from "./parse.ts";
+import { telemetrySession } from "./telemetry/index.ts";
+import { cliVersion } from "./version.ts";
+
+/** What the runner reads and writes; the binary passes the process's, tests their own. */
+export interface RunnerIo {
+  /** The words after mostra. */
+  readonly argv: readonly string[];
+  /** The environment. */
+  readonly env: Environment;
+  /** The working directory. */
+  readonly cwd: string;
+  /** Writes to stdout. */
+  readonly stdout: (text: string) => void;
+  /** Writes to stderr. */
+  readonly stderr: (text: string) => void;
+  /** Standard input. */
+  readonly stdin: NodeJS.ReadableStream;
+  /** Which of the streams are terminals. */
+  readonly tty: { readonly stdin: boolean; readonly stdout: boolean; readonly stderr: boolean };
+  /** The platform; default process.platform. */
+  readonly platform?: string;
+}
+
+/** The diagnostic an exception is, for the envelope: its own, or an internal error. */
+function diagnosticOf(error: unknown): Diagnostic {
+  if (error instanceof RpcError) return error.diagnostic;
+  return createDiagnostic("MOSTRA_HOST_INTERNAL_ERROR", {
+    message: `mostra failed unexpectedly: ${error instanceof Error ? error.message : String(error)}`,
+  });
+}
+
+/** A diagnostic for people, on stderr. */
+function describe(diagnostic: Diagnostic): string {
+  const hint = diagnostic.hint ? `\n  ${diagnostic.hint}` : "";
+  const fix =
+    diagnostic.fix?.kind === "command" && diagnostic.fix.command
+      ? `\n  Run: ${diagnostic.fix.command}`
+      : "";
+  return `${diagnostic.severity} ${diagnostic.code}: ${diagnostic.message}${hint}${fix}\n  ${diagnostic.docs}\n`;
+}
+
+/** Reads the whole of stdin. */
+function readAll(stream: NodeJS.ReadableStream): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    stream.on("data", (chunk: Buffer | string) =>
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)),
+    );
+    stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    stream.on("error", reject);
+  });
+}
+
+/** Asks one question on stderr, read from stdin: the answer, `undefined` after the timeout, or Ctrl-C. */
+function ask(
+  io: RunnerIo,
+  question: string,
+  timeoutMs: number,
+): Promise<string | undefined | "interrupt"> {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: io.stdin, output: process.stderr, terminal: true });
+    let done = false;
+    const finish = (answer: string | undefined | "interrupt"): void => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      rl.close();
+      resolve(answer);
+    };
+    const timer = setTimeout(() => {
+      io.stderr("\n");
+      finish(undefined);
+    }, timeoutMs);
+    rl.on("SIGINT", () => {
+      io.stderr("\n");
+      finish("interrupt");
+    });
+    rl.on("close", () => finish(""));
+    rl.question(question, (answer) => finish(answer));
+  });
+}
+
+/** Runs one command line and returns its exit code. */
+export async function run(io: RunnerIo): Promise<number> {
+  const started = Date.now();
+  const global = globalFlags(io.argv);
+  const json = global.json;
+  const warnings: Diagnostic[] = [];
+  let summary: InstanceSummary | undefined;
+  let connection: InstanceConnection | undefined;
+  let streamed = false;
+
+  const writeJson = (value: unknown): void => io.stdout(`${JSON.stringify(value)}\n`);
+  const fail = (diagnostic: Diagnostic): number => {
+    if (json) {
+      writeJson({
+        ok: false,
+        error: diagnostic,
+        ...(summary && !streamed ? { instance: summary } : {}),
+        warnings,
+      });
+    } else io.stderr(describe(diagnostic));
+    return exitCodeFor(diagnostic.code);
+  };
+
+  // Every entry point fails closed on an unsupported platform before touching the home (D35).
+  const platform = io.platform ?? process.platform;
+  if (platform !== "darwin" && platform !== "linux") {
+    return fail(
+      createDiagnostic("MOSTRA_PLATFORM_UNSUPPORTED", {
+        message: `Mostra runs on macOS and Linux; this is ${platform}.`,
+      }),
+    );
+  }
+
+  let parsed: ReturnType<typeof parseCommandLine>;
+  try {
+    parsed = parseCommandLine(COMMANDS, io.argv);
+  } catch (error) {
+    return fail(diagnosticOf(error));
+  }
+  if (parsed.kind === "version") {
+    if (json) writeJson({ ok: true, result: { version: cliVersion() }, warnings });
+    else io.stdout(`${cliVersion()}\n`);
+    return EXIT.ok;
+  }
+  if (parsed.kind === "help") {
+    if (json) {
+      const result = parsed.command
+        ? commandDefinition(parsed.command)
+        : {
+            commands: COMMANDS.filter(
+              (command) => !parsed.group || command.path[0] === parsed.group,
+            ).map(commandDefinition),
+          };
+      writeJson({ ok: true, result, warnings });
+    } else {
+      io.stdout(
+        parsed.command
+          ? commandHelp(parsed.command)
+          : parsed.group
+            ? groupHelp(COMMANDS, parsed.group)
+            : topHelp(COMMANDS),
+      );
+    }
+    return EXIT.ok;
+  }
+
+  const { command } = parsed;
+  if (global.timeoutMs !== undefined && UNBOUNDED.has(command.path[0] ?? "")) {
+    return fail(
+      createDiagnostic("MOSTRA_CLI_USAGE", {
+        message: `mostra ${commandName(command)} runs until Ctrl-C or its connection ends, so --timeout doesn't apply to it.`,
+      }),
+    );
+  }
+  // `wait --timeout` is the wait's own length, which ends with still_waiting (exit 5), never exit 4.
+  const timeoutMs = command.path[0] === "wait" ? undefined : global.timeoutMs;
+  const cwd = global.cwd !== undefined ? resolve(io.cwd, global.cwd) : io.cwd;
+  const home = resolveHome({ home: global.home, env: io.env, cwd, platform });
+  const config = configDir(io.env, cwd);
+  const marks = readHomeMarks(home);
+  const readsStdin =
+    typeof command.readsStdin === "function"
+      ? command.readsStdin(parsed.flags)
+      : command.readsStdin === true;
+  const telemetry = telemetrySession({
+    env: io.env,
+    configDir: config,
+    command: commandName(command),
+    json,
+    tty: io.tty,
+    readsStdin,
+    quiet: command.quiet === true,
+    hostHome: embeddedHome(marks),
+    stderr: io.stderr,
+    ask: (question, timeoutMs) => ask(io, question, timeoutMs),
+  });
+
+  let connectionClosed = false;
+  // Whether this command is starting the home's daemon: a --timeout that runs out then says so.
+  let startingDaemon = false;
+  const getConnection = async (autostart = true): Promise<InstanceConnection | undefined> => {
+    // A session the instance ended (`daemon stop` before `daemon restart`) is opened again.
+    if (connection && !connectionClosed) return connection;
+    connectionClosed = false;
+    const opened = await connect({
+      home,
+      env: io.env,
+      autostart,
+      onStarting: (starting) => {
+        startingDaemon = starting;
+      },
+    });
+    if (!opened) return undefined;
+    connection = opened;
+    void opened.closed.then(() => {
+      if (connection === opened) connectionClosed = true;
+    });
+    summary = opened.summary;
+    for (const warning of opened.warnings) {
+      warnings.push(warning);
+      io.stderr(describe(warning));
+    }
+    return opened;
+  };
+
+  const context: CommandContext = {
+    args: parsed.args,
+    flags: parsed.flags,
+    cwd,
+    json,
+    timeoutMs,
+    env: io.env,
+    tty: io.tty,
+    home,
+    configDir: config,
+    stdout: io.stdout,
+    stderr: io.stderr,
+    async call<P, R>(method: MethodDefinition<P, R>, params: P): Promise<R> {
+      const session = await getConnection();
+      if (!session)
+        throw new RpcError(
+          createDiagnostic("MOSTRA_HOST_CONNECTION_CLOSED", {
+            message: "No instance runs for this home.",
+          }),
+        );
+      const remaining =
+        timeoutMs === undefined ? undefined : Math.max(1, timeoutMs - (Date.now() - started));
+      return session.call(method, params, remaining);
+    },
+    connection: getConnection,
+    readStdin: () => readAll(io.stdin),
+    log: (line) => io.stderr(`${line}\n`),
+    emit(event, human) {
+      if (json) {
+        writeJson({ ok: true, event, ...(summary && !streamed ? { instance: summary } : {}) });
+        streamed = true;
+      } else if (human !== undefined) io.stdout(human);
+    },
+    warn(diagnostic) {
+      warnings.push(diagnostic);
+      io.stderr(describe(diagnostic));
+    },
+    record: (event) => telemetry.record(event),
+    runtime: (args, stdio = "pipe") => runRuntime(io, args, stdio),
+  };
+
+  let exit: number;
+  let error: string | undefined;
+  try {
+    // Telemetry never stops a command: a failure in it is a run without telemetry.
+    if (!(await telemetry.begin().catch(() => true))) return 130;
+    const outcome: CommandOutcome = await withTimeout(
+      command,
+      context,
+      timeoutMs,
+      () => startingDaemon,
+    );
+    exit = outcome.exit ?? EXIT.ok;
+    if (outcome.raw) return exit;
+    if (json) {
+      writeJson({
+        ok: true,
+        result: outcome.result ?? null,
+        ...(summary && !streamed && command.local !== true ? { instance: summary } : {}),
+        warnings,
+      });
+    } else io.stdout(outcome.human ?? `${JSON.stringify(outcome.result, null, 2)}\n`);
+  } catch (caught) {
+    const diagnostic = diagnosticOf(caught);
+    error = diagnostic.code;
+    exit = fail(diagnostic);
+  } finally {
+    connection?.close();
+  }
+  try {
+    telemetry.end({
+      exit,
+      durationMs: Date.now() - started,
+      hostInstance: summary?.mode === "host",
+      ...(error !== undefined ? { error } : {}),
+    });
+  } catch {
+    // Telemetry never changes a command's outcome.
+  }
+  return exit;
+}
+
+/**
+ * Runs a command, bounded by `--timeout` (exit 4 with `MOSTRA_HOST_TIMEOUT`). `host` and `dev` run
+ * until their connection or Ctrl-C ends them, so `--timeout` bounds neither.
+ */
+async function withTimeout(
+  command: CommandDef,
+  context: CommandContext,
+  timeoutMs: number | undefined,
+  startingDaemon: () => boolean,
+): Promise<CommandOutcome> {
+  if (timeoutMs === undefined || command.path[0] === "host" || command.path[0] === "dev")
+    return command.run(context);
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      command.run(context),
+      new Promise<never>((_, reject) => {
+        timer = setTimeout(
+          () =>
+            reject(
+              new RpcError(
+                createDiagnostic("MOSTRA_HOST_TIMEOUT", {
+                  // One timer owns the deadline and names what was underway (Opus review
+                  // finding 7): starting the daemon, or the command itself.
+                  message: startingDaemon()
+                    ? `The home's daemon didn't start within ${timeoutMs} ms (--timeout).`
+                    : `mostra ${commandName(command)} didn't finish within --timeout (${timeoutMs} ms); what it asked for may still take effect.`,
+                }),
+              ),
+            ),
+          timeoutMs,
+        );
+      }),
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/** Runs `mostra-runtime …` and collects its stdout. */
+async function runRuntime(
+  io: RunnerIo,
+  args: readonly string[],
+  stdio: "pipe" | "inherit",
+): Promise<{ code: number; stdout: string }> {
+  const runtime = await locateRuntime(io.env);
+  return new Promise((resolve) => {
+    const child = spawn(runtime.node, [runtime.entry, ...args], {
+      stdio: stdio === "inherit" ? "inherit" : ["ignore", "pipe", "pipe"],
+      env: io.env as NodeJS.ProcessEnv,
+    });
+    let stdout = "";
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk: string) => {
+      stdout += chunk;
+    });
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk: string) => io.stderr(chunk));
+    child.on("error", () => resolve({ code: EXIT.environment, stdout }));
+    // `close`, not `exit`: the line may still be in the pipe when the process has exited.
+    child.on("close", (code) => resolve({ code: code ?? EXIT.environment, stdout }));
+  });
+}

package/src/telemetry/decision.ts

@@ -0,0 +1,101 @@
+/**
+ * Whether telemetry sends, and why (D140 item 3). The first match decides, so an explicit "off"
+ * anywhere wins over any "on", and withdrawn consent sticks.
+ */
+import type { Environment } from "../home.ts";
+import type { ReadSettings } from "./store.ts";
+import type { TelemetryReason } from "./words.ts";
+
+/** The endpoint this build sends to, set only by the release workflow at bundle time (D140 item 7). */
+declare const __MOSTRA_TELEMETRY_ENDPOINT__: string | undefined;
+
+/** The build's endpoint: empty in this package and in every development build. */
+export function buildEndpoint(): string {
+  return typeof __MOSTRA_TELEMETRY_ENDPOINT__ === "string" ? __MOSTRA_TELEMETRY_ENDPOINT__ : "";
+}
+
+/** What the decision reads. */
+export interface DecisionInputs {
+  readonly env: Environment;
+  /** The build's endpoint ({@link buildEndpoint}); tests pass their own. */
+  readonly buildEndpoint: string;
+  /** Whether this use is embedded: a host-spawned instance, or a home a host configures. */
+  readonly embedded: boolean;
+  readonly settings: ReadSettings;
+  /** Whether this machine's time zone asks first. */
+  readonly askFirst: boolean;
+}
+
+/** The decision. */
+export interface TelemetryDecision {
+  readonly enabled: boolean;
+  readonly reason: TelemetryReason;
+  readonly askFirst: boolean;
+  /** The endpoint events go to, when there is one. */
+  readonly endpoint?: string;
+  /** For an enabled decision: whether the person said yes, or it is the default. */
+  readonly consent?: "explicit" | "default";
+}
+
+const OFF_VALUES = new Set(["0", "false", "off", "no"]);
+const ON_VALUES = new Set(["1", "true", "on", "yes"]);
+
+/** `DO_NOT_TRACK` and `MOSTRA_OFFLINE`'s parser: set to anything but empty, `0` or `false`. */
+export function truthy(value: string | undefined): boolean {
+  if (value === undefined) return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized !== "" && normalized !== "0" && normalized !== "false";
+}
+
+/**
+ * The endpoint in use: `MOSTRA_TELEMETRY_ENDPOINT` when it is `https:` or `http:` to a loopback
+ * address, else the build's; `undefined` when there is none (D140 item 7).
+ */
+export function endpointOf(env: Environment, build: string): string | undefined {
+  const override = env["MOSTRA_TELEMETRY_ENDPOINT"];
+  const chosen = override !== undefined && override !== "" ? override : build;
+  if (chosen === "") return undefined;
+  let url: URL;
+  try {
+    url = new URL(chosen);
+  } catch {
+    return undefined;
+  }
+  if (url.username !== "" || url.password !== "") return undefined;
+  if (url.protocol === "https:") return url.href;
+  const loopback =
+    url.hostname === "127.0.0.1" || url.hostname === "[::1]" || url.hostname === "localhost";
+  return url.protocol === "http:" && loopback ? url.href : undefined;
+}
+
+/** Decides, in D140's order. */
+export function decide(inputs: DecisionInputs): TelemetryDecision {
+  const { askFirst } = inputs;
+  const off = (reason: TelemetryReason): TelemetryDecision => ({
+    enabled: false,
+    reason,
+    askFirst,
+  });
+  const endpoint = endpointOf(inputs.env, inputs.buildEndpoint);
+  if (endpoint === undefined) return off("no-collector");
+  const at = { askFirst, endpoint };
+  if (inputs.embedded) return { ...at, enabled: false, reason: "embedded" };
+  if (truthy(inputs.env["DO_NOT_TRACK"])) return { ...at, enabled: false, reason: "do-not-track" };
+  const variable = inputs.env["MOSTRA_TELEMETRY"];
+  const normalized = variable?.trim().toLowerCase();
+  if (normalized !== undefined && OFF_VALUES.has(normalized)) {
+    return { ...at, enabled: false, reason: "variable" };
+  }
+  if (!inputs.settings.ok) return { ...at, enabled: false, reason: "unreadable" };
+  const choice = inputs.settings.settings.choice;
+  if (choice === "off") return { ...at, enabled: false, reason: "setting" };
+  if (normalized !== undefined && normalized !== "") {
+    return ON_VALUES.has(normalized)
+      ? { ...at, enabled: true, reason: "variable", consent: "explicit" }
+      : { ...at, enabled: false, reason: "variable-invalid" };
+  }
+  if (choice === "on") return { ...at, enabled: true, reason: "setting", consent: "explicit" };
+  return askFirst
+    ? { ...at, enabled: false, reason: "default" }
+    : { ...at, enabled: true, reason: "default", consent: "default" };
+}

package/src/telemetry/events.ts

@@ -0,0 +1,147 @@
+/**
+ * Telemetry's event schema 1 (D140 item 8), the one published in `docs/reference/telemetry.md`.
+ * Every event is checked against it before it is queued and again before it is sent, so nothing
+ * that isn't on that page can leave the machine: the objects are strict, every string is from a
+ * closed set or a pattern, and no field takes free text.
+ */
+import { DIAGNOSTIC_AREAS } from "@mostra/protocol";
+import * as z from "zod";
+import { HARNESSES, type Harness } from "./harness.ts";
+
+/** The schema version every event carries. */
+export const SCHEMA = 1;
+
+/** The duration buckets of `cli.command`. */
+export const DURATIONS = ["<1s", "1-5s", "5-30s", "30s-2m", "2-10m", ">10m"] as const;
+
+/** A command's duration bucket. */
+export function durationBucket(ms: number): (typeof DURATIONS)[number] {
+  if (ms < 1000) return "<1s";
+  if (ms < 5000) return "1-5s";
+  if (ms < 30_000) return "5-30s";
+  if (ms < 120_000) return "30s-2m";
+  if (ms < 600_000) return "2-10m";
+  return ">10m";
+}
+
+/** A catalog-shaped diagnostic code: `MOSTRA_<AREA>_<NAME>`, never a message. */
+const code = z
+  .string()
+  .regex(new RegExp(`^MOSTRA_(${DIAGNOSTIC_AREAS.join("|")})_[A-Z0-9_]{1,64}$`));
+
+/** A command path from the definitions: lowercase words. */
+const command = z.string().regex(/^[a-z]+( [a-z]+)?$/);
+
+const common = {
+  schema: z.literal(SCHEMA),
+  at: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:00Z$/),
+  installId: z.uuid(),
+  version: z.string().regex(/^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/),
+  os: z.enum(["darwin", "linux"]),
+  arch: z.string().regex(/^[a-z0-9]{2,12}$/),
+  node: z.int().min(0).max(999),
+  harness: z.enum([...HARNESSES, "other", "none"]),
+  ci: z.boolean(),
+  consent: z.enum(["explicit", "default"]),
+};
+
+/** The fields every event carries. */
+export interface CommonFields {
+  readonly schema: typeof SCHEMA;
+  readonly at: string;
+  readonly installId: string;
+  readonly version: string;
+  readonly os: "darwin" | "linux";
+  readonly arch: string;
+  readonly node: number;
+  readonly harness: Harness;
+  readonly ci: boolean;
+  readonly consent: "explicit" | "default";
+}
+
+/** One event, as sent (D140 item 8). */
+export type TelemetryEvent = CommonFields &
+  (
+    | { readonly event: "cli.first_run" }
+    | {
+        readonly event: "cli.command";
+        readonly command: string;
+        readonly exit: number;
+        readonly duration: (typeof DURATIONS)[number];
+        readonly json: boolean;
+        readonly error?: string | undefined;
+      }
+    | {
+        readonly event: "verify.result";
+        readonly status: "pass" | "fail";
+        readonly codes: readonly string[];
+        readonly codesTruncated: boolean;
+      }
+    | { readonly event: "publish.done"; readonly reused: boolean; readonly forced: boolean }
+    | {
+        readonly event: "share.done";
+        readonly kind: "tailnet" | "funnel" | "cloudflare" | "remote";
+      }
+    | {
+        readonly event: "mcp.session";
+        readonly client: (typeof HARNESSES)[number] | "other";
+        readonly clientVersion?: string | undefined;
+      }
+  );
+
+/** Every event Mostra may send, as a strict union on `event`. */
+export const TelemetryEvent: z.ZodType<TelemetryEvent> = z.discriminatedUnion("event", [
+  z.strictObject({ ...common, event: z.literal("cli.first_run") }),
+  z.strictObject({
+    ...common,
+    event: z.literal("cli.command"),
+    command,
+    exit: z.int().min(0).max(255),
+    duration: z.enum(DURATIONS),
+    json: z.boolean(),
+    error: code.optional(),
+  }),
+  z.strictObject({
+    ...common,
+    event: z.literal("verify.result"),
+    status: z.enum(["pass", "fail"]),
+    codes: z.array(code).max(50),
+    codesTruncated: z.boolean(),
+  }),
+  z.strictObject({
+    ...common,
+    event: z.literal("publish.done"),
+    reused: z.boolean(),
+    forced: z.boolean(),
+  }),
+  // Emitted by WP-13 and WP-29.
+  z.strictObject({
+    ...common,
+    event: z.literal("share.done"),
+    kind: z.enum(["tailnet", "funnel", "cloudflare", "remote"]),
+  }),
+  // Emitted by WP-15: a known agent's ID for the MCP client, or `other`; its version only then.
+  z.strictObject({
+    ...common,
+    event: z.literal("mcp.session"),
+    client: z.enum([...HARNESSES, "other"]),
+    clientVersion: z
+      .string()
+      .regex(/^[0-9A-Za-z.+-]{1,32}$/)
+      .optional(),
+  }),
+]);
+
+/** `at`: now in UTC, rounded down to the minute. */
+export function minute(now: Date): string {
+  return `${now.toISOString().slice(0, 16)}:00Z`;
+}
+
+/** The distinct catalog codes of `codes`, sorted, at most 50, and whether some were left out. */
+export function catalogCodes(
+  codes: readonly string[],
+  known: ReadonlySet<string>,
+): { codes: string[]; codesTruncated: boolean } {
+  const distinct = [...new Set(codes.filter((value) => known.has(value)))].sort();
+  return { codes: distinct.slice(0, 50), codesTruncated: distinct.length > 50 };
+}

package/src/telemetry/flush-main.ts

@@ -0,0 +1,13 @@
+/**
+ * The flusher process (D140 item 6): `node flush-main.js <config dir>`, started detached by the
+ * CLI. It sends what the queue holds and exits; nothing it does reaches the command that started
+ * it.
+ */
+import { flush } from "./flush.ts";
+import { TelemetryStore } from "./store.ts";
+
+const dir = process.argv[2];
+if (dir !== undefined) {
+  await flush(new TelemetryStore(dir), process.env, Date.now).catch(() => {});
+}
+process.exit(0);