@irtio/cli 0.1.0

package/dist/simulate.js

@@ -0,0 +1,221 @@
+// src/simulate.ts
+import { existsSync } from "fs";
+import { mkdir } from "fs/promises";
+import * as path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+import { randomScript, relayEchoScript, spawnBots } from "@irtio/bots";
+import * as esbuild from "esbuild";
+import pc from "picocolors";
+var DEFAULT_URL = "ws://localhost:7070";
+var DEFAULT_BOTS = 5;
+var DEFAULT_SECONDS = 10;
+var SCHEMA_CANDIDATES = ["irtio/schema.ts", "irtio/schema.js", "schema.ts"];
+function positive(raw, flag) {
+  const value = Number(raw);
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`irtio simulate: ${flag} must be a positive number`);
+  }
+  return value;
+}
+function parseSimulateArgs(args) {
+  const parsed = { bots: DEFAULT_BOTS, seconds: DEFAULT_SECONDS, cheat: false };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const eq = arg.indexOf("=");
+    const flag = eq === -1 ? arg : arg.slice(0, eq);
+    const inline = eq === -1 ? void 0 : arg.slice(eq + 1);
+    const value = () => {
+      const v = inline ?? args[++i];
+      if (v === void 0) throw new Error(`irtio simulate: ${flag} needs a value`);
+      return v;
+    };
+    switch (flag) {
+      case "--bots": {
+        const bots = positive(value(), "--bots");
+        if (!Number.isInteger(bots))
+          throw new Error("irtio simulate: --bots must be a whole number");
+        parsed.bots = bots;
+        break;
+      }
+      case "--seconds":
+        parsed.seconds = positive(value(), "--seconds");
+        break;
+      case "--room":
+        parsed.room = value();
+        break;
+      case "--url":
+        parsed.url = value();
+        break;
+      case "--key":
+        parsed.key = value();
+        break;
+      case "--trace":
+        parsed.trace = value();
+        break;
+      case "--cheat":
+        parsed.cheat = true;
+        break;
+      default:
+        throw new Error(`irtio simulate: unknown option ${JSON.stringify(arg)}`);
+    }
+  }
+  return parsed;
+}
+function monorepoPackages() {
+  const packagesDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+  const schema = path.join(packagesDir, "schema/src/index.ts");
+  if (!existsSync(schema)) return void 0;
+  return {
+    "@irtio/schema": schema,
+    "@irtio/protocol": path.join(packagesDir, "protocol/src/index.ts"),
+    "@irtio/server": path.join(packagesDir, "server/src/index.ts")
+  };
+}
+function looksLikeSchema(value) {
+  const candidate = value;
+  return typeof candidate === "object" && candidate !== null && Array.isArray(candidate.collections) && candidate.hash8 instanceof Uint8Array;
+}
+async function loadProjectSchema(options) {
+  const entry = SCHEMA_CANDIDATES.map((c) => path.resolve(options.cwd, c)).find(
+    (f) => existsSync(f)
+  );
+  if (entry === void 0) return void 0;
+  await mkdir(options.outDir, { recursive: true });
+  const outfile = path.join(options.outDir, "schema.mjs");
+  const alias = options.irtioPackages ?? monorepoPackages();
+  await esbuild.build({
+    entryPoints: [entry],
+    bundle: true,
+    format: "esm",
+    platform: "node",
+    outfile,
+    ...alias !== void 0 ? { alias } : {}
+  });
+  const module = await import(`${pathToFileURL(outfile).href}?v=${Date.now()}`);
+  const schema = module.schema ?? module.default;
+  if (!looksLikeSchema(schema)) {
+    const names = Object.keys(module).join(", ") || "nothing";
+    throw new Error(
+      `irtio simulate: ${entry} does not export a schema.
+  it exports: ${names}
+  add \`export const schema = defineSchema({ ... })\` (this is what \`irtio init\` writes)`
+    );
+  }
+  return { schema, file: entry };
+}
+function rate(bytesPerSecond) {
+  return bytesPerSecond >= 1e3 ? `${(bytesPerSecond / 1e3).toFixed(1)} kB/s` : `${Math.round(bytesPerSecond)} B/s`;
+}
+function formatReport(report, schemaLoaded, cheating) {
+  const lines = [];
+  for (const invariant of report.invariants) {
+    const mark = invariant.ok ? pc.green("ok  ") : pc.red("FAIL");
+    lines.push(`  ${mark} ${invariant.name.padEnd(17)} ${pc.dim(invariant.detail)}`);
+  }
+  lines.push("");
+  const convergence = report.convergenceLagMs === void 0 ? "convergence not sampled" : `convergence ${report.convergenceLagMs} ms (p50 of ${report.convergence?.samples ?? 0})`;
+  lines.push(
+    pc.dim(
+      `  ${report.framesPerSecond} frames/s \xB7 in ${rate(report.bytesInPerSecondPerBot)}/bot \xB7 out ${rate(report.bytesOutPerSecondPerBot)}/bot \xB7 ${report.totals.corrections} corrections \xB7 ${convergence}`
+    )
+  );
+  if (report.tracePath !== void 0) lines.push(pc.dim(`  trace: ${report.tracePath}`));
+  lines.push("");
+  const failed = report.invariants.filter((i) => !i.ok);
+  if (failed.length === 0) {
+    lines.push(pc.green(`  every invariant held across ${report.bots} bots.`));
+  } else {
+    lines.push(
+      pc.red(`  ${failed.length} invariant(s) failed: ${failed.map((i) => i.name).join(", ")}`)
+    );
+  }
+  if (cheating && report.totals.corrections === 0) {
+    lines.push(
+      pc.yellow(
+        "  --cheat drew no corrections: the room accepted every illegal write.\n  add rules to `validate` in irtio/room.ts (reject by returning `prev`, or clamp)."
+      )
+    );
+  }
+  if (!schemaLoaded) {
+    lines.push(
+      pc.yellow(
+        "  no irtio/schema.ts here, so this was a schema-less relay run: presence and messages only.\n  run it from a project directory to simulate your room."
+      )
+    );
+  }
+  return lines;
+}
+async function runSimulation(options = {}) {
+  const cwd = path.resolve(options.cwd ?? process.cwd());
+  const output = [];
+  const log = (line) => {
+    output.push(line);
+    (options.log ?? ((l) => console.log(l)))(line);
+  };
+  const bots = options.bots ?? DEFAULT_BOTS;
+  const seconds = options.seconds ?? DEFAULT_SECONDS;
+  const url = options.url ?? DEFAULT_URL;
+  const outDir = path.join(cwd, ".irtio", "sim");
+  const loaded = await loadProjectSchema({
+    cwd,
+    outDir,
+    irtioPackages: options.irtioPackages
+  });
+  const common = {
+    url,
+    durationMs: seconds * 1e3,
+    ...options.key !== void 0 ? { key: options.key } : {},
+    ...options.room !== void 0 ? { room: options.room } : {}
+  };
+  const runner = loaded ? await spawnBots(bots, {
+    ...common,
+    schema: loaded.schema,
+    script: randomScript(loaded.schema, { cheat: options.cheat ?? false })
+  }) : await spawnBots(bots, { ...common, script: relayEchoScript() });
+  log("");
+  log(
+    `${pc.bold("irtio simulate")} \u2014 ${bots} bot${bots === 1 ? "" : "s"} \xD7 ${seconds}s on ${url} (room ${pc.bold(runner.roomId)})${options.cheat ? pc.yellow(" [cheat]") : ""}`
+  );
+  log("");
+  await runner.done();
+  const stopped = await runner.stop();
+  await mkdir(outDir, { recursive: true });
+  const tracePath = path.resolve(
+    cwd,
+    options.trace ?? path.join(outDir, `trace-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.json`)
+  );
+  await mkdir(path.dirname(tracePath), { recursive: true });
+  await runner.trace.save(tracePath);
+  const report = { ...stopped, tracePath };
+  for (const line of formatReport(report, loaded !== void 0, options.cheat ?? false)) {
+    log(line);
+  }
+  for (const failure of runner.scriptErrors) {
+    log(pc.red(`  bot ${failure.bot} script failed: ${String(failure.error)}`));
+  }
+  return { report, tracePath, schema: loaded !== void 0, output };
+}
+async function simulate(args) {
+  let parsed;
+  try {
+    parsed = parseSimulateArgs(args);
+  } catch (err) {
+    console.error(pc.red(err instanceof Error ? err.message : String(err)));
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const run = await runSimulation(parsed);
+    if (!run.report.ok) process.exitCode = 1;
+  } catch (err) {
+    console.error(pc.red(err instanceof Error ? err.message : String(err)));
+    console.error(pc.dim("is `irtio dev` running? pass --url to point somewhere else."));
+    process.exitCode = 1;
+  }
+}
+export {
+  loadProjectSchema,
+  parseSimulateArgs,
+  runSimulation,
+  simulate
+};

package/dist/whoami-5Q32SXFX.js

@@ -0,0 +1,63 @@
+import {
+  createApiClient,
+  isLoginRequired
+} from "./chunk-J3G6AUJY.js";
+import {
+  resolveControlUrlForUser
+} from "./chunk-UYN5PWLT.js";
+
+// src/whoami.ts
+import pc from "picocolors";
+function parseWhoamiArgs(args) {
+  const parsed = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--url": {
+        const value = args[++i];
+        if (value === void 0) throw new Error("irtio whoami: --url needs a value");
+        parsed.url = value;
+        break;
+      }
+      default:
+        throw new Error(`irtio whoami: unknown option ${JSON.stringify(arg)}`);
+    }
+  }
+  return parsed;
+}
+async function runWhoami(options = {}) {
+  const log = options.log ?? ((line) => console.log(line));
+  const controlUrl = await resolveControlUrlForUser(options.controlUrl);
+  const client = options.client ?? await createApiClient(controlUrl);
+  const me = await client.get("/v1/me");
+  log(`${pc.green(me.email)}${me.isAdmin ? pc.dim(" (admin)") : ""}`);
+  log(pc.dim(`org: ${me.orgId}`));
+  log(pc.dim(`control plane: ${me.controlUrl}`));
+  return me;
+}
+async function whoami(args, deps = {}) {
+  const log = deps.log ?? ((line) => console.log(line));
+  const errorLog = deps.errorLog ?? ((line) => console.error(line));
+  try {
+    const parsed = parseWhoamiArgs(args);
+    await runWhoami({
+      log,
+      ...parsed.url !== void 0 ? { controlUrl: parsed.url } : {},
+      ...deps.client !== void 0 ? { client: deps.client } : {}
+    });
+  } catch (err) {
+    if (isLoginRequired(err)) {
+      errorLog(pc.red("not logged in"));
+      errorLog("run: irtio login");
+      process.exitCode = 1;
+      return;
+    }
+    errorLog(pc.red(err instanceof Error ? err.message : String(err)));
+    process.exitCode = 1;
+  }
+}
+export {
+  parseWhoamiArgs,
+  runWhoami,
+  whoami
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@irtio/cli",
+  "version": "0.1.0",
+  "description": "irtio CLI: local dev server, room scaffolding, bot simulation, deploy, logs and rooms",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./bundle": {
+      "types": "./dist/bundle.d.ts",
+      "import": "./dist/bundle.js"
+    }
+  },
+  "bin": {
+    "irtio": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "esbuild": "^0.27.3",
+    "picocolors": "^1.1.1",
+    "ws": "^8.18.0",
+    "@irtio/bots": "0.1.0",
+    "@irtio/client": "0.1.0",
+    "@irtio/protocol": "0.1.0",
+    "@irtio/runtime": "0.1.0",
+    "@irtio/schema": "0.1.0",
+    "@irtio/server": "0.1.0"
+  },
+  "devDependencies": {
+    "@irtio/supervisor": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run"
+  }
+}