rpc-bastion 0.3.0

package/dist/bin.cjs

@@ -0,0 +1,760 @@
+#!/usr/bin/env node
+'use strict';
+
+var fs = require('fs');
+var kit = require('@solana/kit');
+var sender = require('@rpc-bastion/sender');
+var core = require('@rpc-bastion/core');
+var testkit = require('@rpc-bastion/testkit');
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/data/args.ts
+var args_exports = {};
+__export(args_exports, {
+  flagBool: () => flagBool,
+  flagInt: () => flagInt,
+  flagString: () => flagString,
+  parseArgs: () => parseArgs
+});
+function parseArgs(argv) {
+  const flags = {};
+  const positionals = [];
+  let command = null;
+  for (let i = 0; i < argv.length; i++) {
+    const tok = argv[i];
+    if (tok.startsWith("--")) {
+      const body = tok.slice(2);
+      const eq = body.indexOf("=");
+      if (eq >= 0) {
+        flags[body.slice(0, eq)] = body.slice(eq + 1);
+      } else {
+        const next = argv[i + 1];
+        if (next !== void 0 && !next.startsWith("--")) {
+          flags[body] = next;
+          i++;
+        } else {
+          flags[body] = true;
+        }
+      }
+    } else if (command === null) {
+      command = tok;
+    } else {
+      positionals.push(tok);
+    }
+  }
+  return { command, positionals, flags };
+}
+function flagString(args, name) {
+  const v = args.flags[name];
+  return typeof v === "string" ? v : void 0;
+}
+function flagBool(args, name) {
+  return args.flags[name] === true || args.flags[name] === "true";
+}
+function flagInt(args, name, fallback) {
+  const v = args.flags[name];
+  if (typeof v !== "string") return fallback;
+  const n = Number.parseInt(v, 10);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+var init_args = __esm({
+  "src/data/args.ts"() {
+  }
+});
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  COMMANDS: () => COMMANDS,
+  route: () => route
+});
+function route(args) {
+  if (args.flags["help"] === true || args.flags["version"] === true) return "help";
+  const c = args.command;
+  if (c && COMMANDS.includes(c)) return c;
+  return "help";
+}
+var COMMANDS;
+var init_cli = __esm({
+  "src/cli.ts"() {
+    COMMANDS = ["doctor", "monitor", "watch-tx", "simulate", "help"];
+  }
+});
+function median(values) {
+  if (values.length === 0) return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+function describeProbeError(e) {
+  if (e instanceof TypeError) {
+    const stack = e.stack ?? "";
+    if (stack.includes("getHumanReadableErrorMessage") || stack.includes("getSolanaErrorFromJsonRpcError") || stack.includes("@solana/errors")) {
+      return "endpoint returned a JSON-RPC error Solana Kit could not format (often a keyless/unauthorized gateway requiring an API key)";
+    }
+  }
+  return e instanceof Error ? e.message : String(e);
+}
+async function probeEndpoint(url, options) {
+  const { probes, rpc, clock, signal } = options;
+  const latencies = [];
+  let slot = null;
+  let error = null;
+  for (let i = 0; i < probes; i++) {
+    const start = clock.now();
+    try {
+      const s = await rpc.getSlot().send(signal ? { abortSignal: signal } : void 0);
+      latencies.push(clock.now() - start);
+      slot = s;
+    } catch (e) {
+      error ??= describeProbeError(e);
+    }
+  }
+  let health = null;
+  let version = null;
+  if (latencies.length > 0) {
+    try {
+      health = await rpc.getHealth().send(signal ? { abortSignal: signal } : void 0);
+    } catch (e) {
+      error ??= describeProbeError(e);
+    }
+    try {
+      const v = await rpc.getVersion().send(signal ? { abortSignal: signal } : void 0);
+      version = v["solana-core"] ?? null;
+    } catch (e) {
+      error ??= describeProbeError(e);
+    }
+  }
+  const reachable = latencies.length > 0;
+  return {
+    url,
+    reachable,
+    latencyP50Ms: median(latencies),
+    health,
+    slot,
+    slotLag: null,
+    // filled in once the cluster max is known
+    version,
+    error
+  };
+}
+async function runDoctor(urls, options) {
+  const probes = options.probes ?? 5;
+  const clock = options.clock ?? core.systemClock;
+  const diagnostics = await Promise.all(
+    urls.map(
+      (url) => probeEndpoint(url, {
+        probes,
+        rpc: options.rpcFactory(url),
+        clock,
+        ...options.signal ? { signal: options.signal } : {}
+      })
+    )
+  );
+  let clusterMaxSlot = null;
+  for (const d of diagnostics) {
+    if (d.slot !== null && (clusterMaxSlot === null || d.slot > clusterMaxSlot)) clusterMaxSlot = d.slot;
+  }
+  for (const d of diagnostics) {
+    d.slotLag = d.slot !== null && clusterMaxSlot !== null ? Number(clusterMaxSlot - d.slot) : null;
+  }
+  const reachable = diagnostics.filter((d) => d.reachable).length;
+  return { endpoints: diagnostics, clusterMaxSlot, reachable, total: urls.length };
+}
+function doctorReportToJson(report) {
+  return JSON.stringify(
+    report,
+    (_key, value) => typeof value === "bigint" ? value.toString() : value,
+    2
+  );
+}
+
+// src/data/config.ts
+function parseConfig(text) {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (e) {
+    throw new Error(`invalid bastion.config.json: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  if (typeof raw !== "object" || raw === null) throw new Error("bastion.config.json must be an object");
+  const endpoints = raw.endpoints;
+  if (!Array.isArray(endpoints) || endpoints.length === 0 || !endpoints.every((e) => typeof e === "string")) {
+    throw new Error('bastion.config.json must have a non-empty "endpoints" string array');
+  }
+  const jito = raw.jito;
+  const config = { endpoints };
+  if (jito && typeof jito === "object") {
+    const j = jito;
+    config.jito = {
+      ...typeof j.region === "string" ? { region: j.region } : {},
+      ...typeof j.baseUrl === "string" ? { baseUrl: j.baseUrl } : {}
+    };
+  }
+  return config;
+}
+function resolveEndpoints(opts) {
+  if (opts.endpoints) {
+    const list = opts.endpoints.split(",").map((s) => s.trim()).filter(Boolean);
+    if (list.length === 0) throw new Error("--endpoints provided but empty");
+    return list;
+  }
+  if (opts.config) return opts.config.endpoints;
+  throw new Error("no endpoints: pass --endpoints <urls> or --config <bastion.config.json>");
+}
+
+// src/data/monitor.ts
+function statusDot(health) {
+  if (health.breaker === "open" || health.status === "broken") return "red";
+  if (health.breaker === "half-open" || health.status === "degraded" || health.errorRate > 0.1 || (health.slotLag ?? 0) > 50)
+    return "yellow";
+  return "green";
+}
+function summarizeSnapshot(snapshot) {
+  const rows = snapshot.map((h) => ({
+    url: h.url,
+    dot: statusDot(h),
+    latencyMs: Math.round(h.latencyEwmaMs),
+    errorRatePct: Math.round(h.errorRate * 100),
+    slotLag: h.slotLag,
+    breaker: h.breaker,
+    inFlight: h.inFlight
+  }));
+  const healthy = rows.filter((r) => r.dot === "green").length;
+  let maxSlotLag = null;
+  for (const r of rows) {
+    if (r.slotLag !== null && (maxSlotLag === null || r.slotLag > maxSlotLag)) maxSlotLag = r.slotLag;
+  }
+  return { rows, healthy, total: rows.length, maxSlotLag };
+}
+function pushSample(history, sample, size = 30) {
+  const next = [...history, sample];
+  return next.length > size ? next.slice(next.length - size) : next;
+}
+var SCENARIOS = {
+  "live-outage": {
+    name: "live-outage",
+    description: "The movie: 3 healthy endpoints \u2192 the primary blacks out (breaker opens, traffic reroutes) \u2192 it recovers (half-open trial \u2192 closed). Zero failed user calls.",
+    endpoints: ["rpc-a", "rpc-b", "rpc-c"],
+    plans: {
+      // Healthy (mild latency) → total blackout from 1.5s → recovery from 4s.
+      "rpc-a": [
+        { atMs: 0, set: { latency: { minMs: 18, maxMs: 45 } } },
+        { atMs: 1500, set: { dropRate: 1 } },
+        { atMs: 4e3, set: { dropRate: 0, latency: { minMs: 22, maxMs: 50 } } }
+      ],
+      "rpc-b": [{ atMs: 0, set: { latency: { minMs: 25, maxMs: 70 } } }],
+      "rpc-c": [{ atMs: 0, set: { latency: { minMs: 30, maxMs: 85 } } }]
+    },
+    ticks: 14,
+    // Round-robin keeps probing rpc-a during the outage so its failures pile up
+    // and the breaker actually opens; the burst gets there within one tick.
+    strategy: "round-robin",
+    callsPerTick: 3,
+    breaker: { failureThreshold: 3, windowMs: 5e3, cooldownMs: 1e3 }
+  },
+  "flaky-endpoint": {
+    name: "flaky-endpoint",
+    description: "One endpoint degrades (latency + 500s) mid-run; the pool routes away from it.",
+    endpoints: ["rpc-a", "rpc-b"],
+    plans: {
+      "rpc-a": [
+        { atMs: 0, set: {} },
+        { atMs: 2e3, set: { latency: { minMs: 400, maxMs: 800 }, errorRate: { http500: 0.5 } } }
+      ],
+      "rpc-b": []
+    },
+    ticks: 10
+  },
+  "cascading-failure": {
+    name: "cascading-failure",
+    description: "Endpoints fail one after another; the breaker opens and probes recover them.",
+    endpoints: ["rpc-a", "rpc-b", "rpc-c"],
+    plans: {
+      "rpc-a": [{ atMs: 1e3, set: { dropRate: 1 } }],
+      "rpc-b": [{ atMs: 3e3, set: { dropRate: 1 } }],
+      "rpc-c": []
+    },
+    ticks: 12
+  },
+  "rate-limited": {
+    name: "rate-limited",
+    description: "All endpoints throw 429s intermittently; retries with backoff absorb them.",
+    endpoints: ["rpc-a", "rpc-b"],
+    plans: {
+      "rpc-a": [{ atMs: 0, set: { errorRate: { http429: 0.4 } } }],
+      "rpc-b": [{ atMs: 0, set: { errorRate: { http429: 0.4 } } }]
+    },
+    ticks: 10
+  }
+};
+function listScenarios() {
+  return Object.values(SCENARIOS).map((s) => ({ name: s.name, description: s.description }));
+}
+async function runSimulation(scenario, options) {
+  const tickMs = options.tickMs ?? 500;
+  const clock = { now: options.now, sleep: async () => void 0 };
+  const bus = core.createEventBus();
+  const server = testkit.createMockRpcServer({ slot: 1e3, blockHeight: 1e3 });
+  const { pool, rpc } = core.createResilientRpc(
+    scenario.endpoints.map((url) => ({ url })),
+    {
+      bus,
+      clock,
+      ...scenario.strategy ? { strategy: scenario.strategy } : {},
+      ...scenario.breaker ? { breaker: scenario.breaker } : {},
+      pool: {
+        probe: { enabled: false },
+        transportFactory: (config) => testkit.createChaosTransport(server.transport, {
+          plan: scenario.plans[config.url] ?? [],
+          endpointId: config.url,
+          clock,
+          seed: options.seed ?? 42
+        })
+      }
+    }
+  );
+  let pending = [];
+  let lastServed = null;
+  bus.onAny((event) => {
+    switch (event.type) {
+      case "rpc.response":
+        if (event.ok) {
+          lastServed = event.endpoint;
+          pending.push({ kind: "served", endpoint: event.endpoint, detail: `${Math.round(event.latencyMs)}ms` });
+        }
+        break;
+      case "rpc.error":
+        pending.push({ kind: "error", endpoint: event.endpoint, detail: event.errorClass });
+        break;
+      case "rpc.failover":
+        if (event.to) pending.push({ kind: "failover", endpoint: event.to, detail: `${event.from} \u2192 ${event.to}` });
+        break;
+      case "breaker.state":
+        pending.push({
+          kind: event.state === "open" ? "breaker-open" : event.state === "half-open" ? "breaker-half-open" : "breaker-closed",
+          endpoint: event.endpoint,
+          detail: event.state.toUpperCase()
+        });
+        break;
+    }
+  });
+  const callsPerTick = Math.max(1, scenario.callsPerTick ?? 1);
+  const ticks = [];
+  for (let i = 0; i < scenario.ticks; i++) {
+    pending = [];
+    lastServed = null;
+    let userCallOk = true;
+    for (let c = 0; c < callsPerTick; c++) {
+      try {
+        await rpc.getSlot().send();
+      } catch {
+        userCallOk = false;
+      }
+    }
+    const snapshot = pool.getHealthSnapshot();
+    const tick = {
+      tick: i,
+      snapshot,
+      servedBy: userCallOk ? lastServed : null,
+      userCallOk,
+      events: pending
+    };
+    ticks.push(tick);
+    options.onTick?.(tick);
+    await options.advance(tickMs);
+  }
+  return ticks;
+}
+function summarizeSimulation(ticks) {
+  const perEndpoint = /* @__PURE__ */ new Map();
+  const ensure = (url) => {
+    let row = perEndpoint.get(url);
+    if (!row) {
+      row = { url, served: 0, errors: 0 };
+      perEndpoint.set(url, row);
+    }
+    return row;
+  };
+  let userCallsFailed = 0;
+  let breakerOpens = 0;
+  for (const tick of ticks) {
+    if (tick.userCallOk === false) userCallsFailed++;
+    if (tick.servedBy) ensure(tick.servedBy).served++;
+    for (const ev of tick.events ?? []) {
+      if (ev.kind === "error") ensure(ev.endpoint).errors++;
+      if (ev.kind === "breaker-open") breakerOpens++;
+    }
+  }
+  return {
+    userCallsTotal: ticks.length,
+    userCallsFailed,
+    perEndpoint: [...perEndpoint.values()],
+    breakerOpens
+  };
+}
+async function watchTransaction(signature, options) {
+  const clock = options.clock;
+  const engine = sender.createConfirmationEngine({
+    rpc: options.rpc,
+    ...options.rpcSubscriptions ? { rpcSubscriptions: options.rpcSubscriptions } : {},
+    ...clock ? { clock } : {}
+  });
+  const updates = [];
+  const now = () => clock?.now() ?? 0;
+  const push = (state, detail) => {
+    const update = { at: now(), state, detail };
+    updates.push(update);
+    options.onUpdate?.(update);
+  };
+  push("watching", `commitment=${options.commitment ?? "confirmed"}`);
+  const outcome = await engine.confirm(signature, {
+    commitment: options.commitment ?? "confirmed",
+    lastValidBlockHeight: options.lastValidBlockHeight,
+    ...options.pollIntervalMs !== void 0 ? { pollIntervalMs: options.pollIntervalMs } : {},
+    ...options.blockHeightIntervalMs !== void 0 ? { blockHeightIntervalMs: options.blockHeightIntervalMs } : {},
+    ...options.signal ? { signal: options.signal } : {}
+  });
+  switch (outcome.type) {
+    case "confirmed":
+      push("confirmed", `slot ${outcome.slot} (${outcome.confirmationStatus})`);
+      return { signature, outcome: "confirmed", slot: outcome.slot, updates };
+    case "failed":
+      push("failed", "on-chain execution error");
+      return { signature, outcome: "failed", slot: outcome.slot, updates };
+    case "expired":
+      push("expired", `block height ${outcome.blockHeight} > ${outcome.lastValidBlockHeight}`);
+      return { signature, outcome: "expired", slot: null, updates };
+    default:
+      push("aborted", "watch aborted");
+      return { signature, outcome: "aborted", slot: null, updates };
+  }
+}
+
+// src/ui/run.ts
+init_args();
+
+// src/ui/ansi.ts
+var useColor = !process.env.NO_COLOR;
+var wrap = (code) => (s) => useColor ? `\x1B[${code}m${s}\x1B[0m` : s;
+var color = {
+  green: wrap("32"),
+  yellow: wrap("33"),
+  red: wrap("31"),
+  dim: wrap("2"),
+  bold: wrap("1"),
+  cyan: wrap("36")
+};
+function dot(kind) {
+  const ch = "\u25CF";
+  return kind === "green" ? color.green(ch) : kind === "yellow" ? color.yellow(ch) : color.red(ch);
+}
+function table(headers, rows) {
+  const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => stripAnsi(r[i] ?? "").length)));
+  const pad = (s, w) => s + " ".repeat(Math.max(0, w - stripAnsi(s).length));
+  const line = (cols) => cols.map((c, i) => pad(c, widths[i])).join("  ");
+  const head = color.bold(line(headers));
+  const sep = color.dim(widths.map((w) => "\u2500".repeat(w)).join("  "));
+  return [head, sep, ...rows.map(line)].join("\n");
+}
+var SPARK = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+function sparkline(values) {
+  if (values.length === 0) return "";
+  const max = Math.max(...values, 1);
+  return values.map((v) => SPARK[Math.min(SPARK.length - 1, Math.floor(v / max * (SPARK.length - 1)))]).join("");
+}
+function stripAnsi(s) {
+  return s.replace(/\[[0-9;]*m/g, "");
+}
+function clearScreen() {
+  process.stdout.write("\x1B[2J\x1B[H");
+}
+function print(line = "") {
+  console.log(line);
+}
+function bar(fraction, width = 10) {
+  const f = Math.max(0, Math.min(1, fraction));
+  const filled = Math.round(f * width);
+  return "\u2588".repeat(filled) + color.dim("\u2591".repeat(width - filled));
+}
+function breakerWord(state) {
+  const label = state.toUpperCase();
+  return state === "open" ? color.red(label) : state === "half-open" ? color.yellow(label) : color.green(label);
+}
+function comment(text) {
+  return color.dim(`# ${text}`);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/ui/render.ts
+function renderDoctor(report) {
+  const rows = report.endpoints.map((e) => [
+    e.reachable ? dot("green") : dot("red"),
+    e.url,
+    e.latencyP50Ms === null ? "\u2014" : `${e.latencyP50Ms}ms`,
+    e.health ?? "\u2014",
+    e.slot === null ? "\u2014" : String(e.slot),
+    e.slotLag === null ? "\u2014" : `+${e.slotLag}`,
+    e.version ?? "\u2014",
+    e.error ? color.red(e.error) : ""
+  ]);
+  print(table(["", "endpoint", "p50", "health", "slot", "lag", "version", "error"], rows));
+  print();
+  print(color.dim(`${report.reachable}/${report.total} reachable \xB7 cluster slot ${report.clusterMaxSlot ?? "\u2014"}`));
+}
+function renderMonitor(summary, history) {
+  const rows = summary.rows.map((r) => [
+    dot(r.dot),
+    r.url,
+    `${r.latencyMs}ms`,
+    sparkline(history[r.url] ?? []),
+    `${r.errorRatePct}%`,
+    r.slotLag === null ? "\u2014" : `+${r.slotLag}`,
+    r.breaker,
+    String(r.inFlight)
+  ]);
+  print(table(["", "endpoint", "latency", "trend", "err", "lag", "breaker", "inflight"], rows));
+  print();
+  print(color.dim(`${summary.healthy}/${summary.total} healthy \xB7 max lag ${summary.maxSlotLag ?? 0}`));
+}
+function renderWatchTx(result) {
+  for (const u of result.updates) {
+    const c = u.state === "confirmed" ? color.green : u.state === "watching" ? color.cyan : color.red;
+    print(`${color.dim(String(u.at))}  ${c(u.state)}  ${u.detail}`);
+  }
+}
+function renderSimulationTick(tick) {
+  const dots = tick.snapshot.map((h) => {
+    const k = h.breaker === "open" ? "red" : h.errorRate > 0.1 ? "yellow" : "green";
+    return `${dot(k)} ${h.url}`;
+  }).join("   ");
+  print(`tick ${String(tick.tick).padStart(2)}  ${dots}`);
+}
+function dotKind(h) {
+  if (h.breaker === "open" || h.status === "broken") return "red";
+  if (h.breaker === "half-open" || h.status === "degraded" || h.errorRate > 0.1) return "yellow";
+  return "green";
+}
+function renderSimulationHeader(scenario) {
+  print(color.bold("bastion simulate") + color.dim(`  \xB7  scenario: ${scenario.name}`));
+  print(color.dim(scenario.description));
+  print();
+}
+function renderSimulationLiveTick(tick) {
+  const maxLat = Math.max(60, ...tick.snapshot.map((h) => h.latencyEwmaMs));
+  for (const h of tick.snapshot) {
+    const served = tick.servedBy === h.url ? color.cyan(" \u25C0 traffic") : "";
+    const lat = h.latencyEwmaMs > 0 ? `${bar(h.latencyEwmaMs / maxLat, 8)} ${Math.round(h.latencyEwmaMs)}ms` : bar(0, 8);
+    print(`  ${dot(dotKind(h))} ${h.url.padEnd(6)} ${breakerWord(h.breaker).padEnd(18)} ${lat}${served}`);
+  }
+  const probes = (tick.events ?? []).filter((e) => e.kind === "served" || e.kind === "error").map((e) => e.kind === "served" ? `${e.endpoint} ${e.detail}` : color.red(`${e.endpoint} \u2715`));
+  if (probes.length) print(color.dim(`     probes: `) + probes.join(color.dim(" \xB7 ")));
+  for (const ev of tick.events ?? []) {
+    if (ev.kind === "served" || ev.kind === "error") continue;
+    print(`     ${renderTickEvent(ev)}`);
+  }
+}
+function renderTickEvent(ev) {
+  switch (ev.kind) {
+    case "failover":
+      return color.yellow("\u21BB failover ") + color.dim(ev.detail);
+    case "breaker-open":
+      return color.red(`\u2715 breaker ${ev.endpoint} OPEN `) + comment("ejecting endpoint, rerouting traffic");
+    case "breaker-half-open":
+      return color.yellow(`\u25D0 breaker ${ev.endpoint} HALF-OPEN `) + comment("trial request");
+    case "breaker-closed":
+      return color.green(`\u2713 breaker ${ev.endpoint} CLOSED `) + comment("recovered, back in rotation");
+    default:
+      return color.dim(`\xB7 ${ev.endpoint} ${ev.detail}`);
+  }
+}
+function renderSimulationSummary(finalTick, summary) {
+  print();
+  print(color.bold("final health"));
+  const rows = finalTick.snapshot.map((h) => {
+    const served = summary.perEndpoint.find((r) => r.url === h.url)?.served ?? 0;
+    return [dot(dotKind(h)), h.url, breakerWord(h.breaker), `${Math.round(h.latencyEwmaMs)}ms`, `${served} served`];
+  });
+  print(table(["", "endpoint", "breaker", "latency", "traffic"], rows));
+  print();
+  const total = summary.userCallsTotal;
+  const failed = summary.userCallsFailed;
+  const thesis = failed === 0 ? color.green(color.bold(`\u2713 0 failed user calls`)) + color.dim(` across ${total} calls \u2014 ${summary.breakerOpens} breaker trip(s), every call served by a healthy endpoint`) : color.red(color.bold(`\u2715 ${failed}/${total} user calls failed`));
+  print(thesis);
+}
+
+// src/ui/run.ts
+function endpointsFromArgs(args) {
+  const configPath = flagString(args, "config");
+  const config = configPath ? parseConfig(fs.readFileSync(configPath, "utf8")) : void 0;
+  const endpoints = flagString(args, "endpoints");
+  return resolveEndpoints({ ...endpoints ? { endpoints } : {}, ...config ? { config } : {} });
+}
+function doctorRpcFor(url) {
+  return kit.createSolanaRpc(url);
+}
+async function runDoctorCommand(args) {
+  const urls = endpointsFromArgs(args);
+  const report = await runDoctor(urls, {
+    rpcFactory: doctorRpcFor,
+    probes: flagInt(args, "probes", 5),
+    clock: core.systemClock
+  });
+  if (flagBool(args, "json")) {
+    print(doctorReportToJson(report));
+  } else {
+    renderDoctor(report);
+  }
+}
+async function runWatchTxCommand(args) {
+  const sig = args.positionals[0];
+  if (!sig) throw new Error("usage: bastion watch-tx <signature> --endpoints <urls>");
+  const urls = endpointsFromArgs(args);
+  const rpc = sender.asSenderRpc(kit.createSolanaRpc(urls[0]));
+  const subs = kit.createSolanaRpcSubscriptions(urls[0].replace(/^http/, "ws"));
+  const lvbh = BigInt(flagString(args, "last-valid-block-height") ?? "0");
+  const result = await watchTransaction(sig, {
+    rpc,
+    rpcSubscriptions: subs,
+    lastValidBlockHeight: lvbh,
+    clock: core.systemClock,
+    onUpdate: (u) => print(`${color.dim(String(u.at))} ${u.state} ${u.detail}`)
+  });
+  renderWatchTx(result);
+}
+async function runSimulateCommand(args) {
+  const name = flagString(args, "scenario");
+  if (!name || flagBool(args, "list")) {
+    print(color.bold("Available scenarios:"));
+    for (const s of listScenarios()) print(`  ${color.cyan(s.name)} \u2014 ${s.description}`);
+    return;
+  }
+  const scenario = SCENARIOS[name];
+  if (!scenario) throw new Error(`unknown scenario "${name}" (try --list)`);
+  if (flagBool(args, "live")) {
+    await runSimulateLive(args);
+    return;
+  }
+  let t = 0;
+  await runSimulation(scenario, {
+    now: () => t,
+    advance: (ms) => {
+      t += ms;
+    },
+    onTick: (tick) => renderSimulationTick(tick)
+  });
+  print();
+  print(color.dim(`scenario "${scenario.name}" complete`));
+}
+async function runSimulateLive(args) {
+  const scenario = SCENARIOS[flagString(args, "scenario")];
+  const beatMs = Math.max(200, Math.min(700, flagInt(args, "beat", 420)));
+  clearScreen();
+  renderSimulationHeader(scenario);
+  const collected = [];
+  let base = 0;
+  let anchor = performance.now();
+  await runSimulation(scenario, {
+    now: () => base + (performance.now() - anchor),
+    advance: (ms) => {
+      base += ms;
+      anchor = performance.now();
+    },
+    onTick: (tick) => {
+      collected.push(tick);
+    }
+  });
+  for (const tick of collected) {
+    renderSimulationLiveTick(tick);
+    print();
+    await sleep(beatMs);
+  }
+  const last = collected[collected.length - 1];
+  if (last) renderSimulationSummary(last, summarizeSimulation(collected));
+}
+async function runMonitorCommand(args) {
+  const urls = endpointsFromArgs(args);
+  const { pool, rpc } = core.createResilientRpc(urls.map((url) => ({ url })));
+  const history = {};
+  const intervalMs = flagInt(args, "interval", 1e3);
+  const tick = async () => {
+    try {
+      await rpc.getSlot().send();
+    } catch {
+    }
+    const snapshot = pool.getHealthSnapshot();
+    for (const h of snapshot) history[h.url] = pushSample(history[h.url] ?? [], h.latencyEwmaMs);
+    clearScreen();
+    print(color.bold("bastion monitor") + color.dim("  (ctrl-c to exit)"));
+    print();
+    renderMonitor(summarizeSnapshot(snapshot), history);
+  };
+  await tick();
+  const timer = setInterval(() => void tick(), intervalMs);
+  await new Promise((resolve) => {
+    process.on("SIGINT", () => {
+      clearInterval(timer);
+      resolve();
+    });
+  });
+}
+function runHelp() {
+  print(color.bold("bastion") + " \u2014 Solana RPC/transaction resilience diagnostics");
+  print();
+  print("Commands:");
+  print(`  ${color.cyan("doctor")}    --endpoints <urls> | --config <file> [--probes N] [--json]`);
+  print(`  ${color.cyan("monitor")}   --endpoints <urls> | --config <file> [--interval ms]`);
+  print(`  ${color.cyan("watch-tx")}  <signature> --endpoints <urls>`);
+  print(`  ${color.cyan("simulate")}  --scenario <name> [--live] | --list`);
+}
+async function main(argv) {
+  const { parseArgs: parseArgs2 } = await Promise.resolve().then(() => (init_args(), args_exports));
+  const { route: route2 } = await Promise.resolve().then(() => (init_cli(), cli_exports));
+  const args = parseArgs2(argv);
+  try {
+    switch (route2(args)) {
+      case "doctor":
+        await runDoctorCommand(args);
+        break;
+      case "monitor":
+        await runMonitorCommand(args);
+        break;
+      case "watch-tx":
+        await runWatchTxCommand(args);
+        break;
+      case "simulate":
+        await runSimulateCommand(args);
+        break;
+      default:
+        runHelp();
+    }
+    return 0;
+  } catch (e) {
+    console.error(`bastion: ${e instanceof Error ? e.message : String(e)}`);
+    return 1;
+  }
+}
+
+// src/ui/bin.ts
+main(process.argv.slice(2)).then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (err) => {
+    console.error(err);
+    process.exitCode = 1;
+  }
+);
+//# sourceMappingURL=bin.cjs.map
+//# sourceMappingURL=bin.cjs.map