@irtio/cli 0.1.0

package/dist/logs-6GLBO3TP.js

@@ -0,0 +1,122 @@
+import {
+  createApiClient,
+  isLoginRequired
+} from "./chunk-J3G6AUJY.js";
+import {
+  resolveControlUrlForUser
+} from "./chunk-UYN5PWLT.js";
+
+// src/logs.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import * as path from "path";
+import pc from "picocolors";
+var POLL_MS = 2e3;
+function parseLogsArgs(args) {
+  const parsed = {
+    follow: false
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--follow":
+        parsed.follow = true;
+        break;
+      case "--since": {
+        const value = args[++i];
+        if (value === void 0) throw new Error("irtio logs: --since needs a value");
+        parsed.since = value;
+        break;
+      }
+      case "--project": {
+        const value = args[++i];
+        if (value === void 0) throw new Error("irtio logs: --project needs a value");
+        parsed.project = value;
+        break;
+      }
+      case "--url": {
+        const value = args[++i];
+        if (value === void 0) throw new Error("irtio logs: --url needs a value");
+        parsed.url = value;
+        break;
+      }
+      default:
+        throw new Error(`irtio logs: unknown option ${JSON.stringify(arg)}`);
+    }
+  }
+  return parsed;
+}
+function levelColor(level, text) {
+  return level === "error" ? pc.red(text) : level === "warn" ? pc.yellow(text) : pc.dim(text);
+}
+function formatRow(row) {
+  const time = row.at.replace("T", " ").replace(/\.\d+Z$/, "Z");
+  const level = levelColor(row.level, row.level.toUpperCase().padEnd(5));
+  const room = (row.roomId ?? "-").padEnd(12);
+  return `${pc.dim(time)}  ${level}  ${room}  ${row.message}`;
+}
+async function runLogs(options) {
+  const log = options.log ?? ((line) => console.log(line));
+  const controlUrl = await resolveControlUrlForUser(options.controlUrl);
+  const client = options.client ?? await createApiClient(controlUrl);
+  let since = options.since;
+  let polls = 0;
+  for (; ; ) {
+    const rows = await client.get(`/v1/projects/${options.project}/logs`, {
+      since
+    });
+    for (const row of rows) log(formatRow(row));
+    const last = rows[rows.length - 1];
+    if (last !== void 0) since = last.at;
+    if (!options.follow) return since;
+    polls += 1;
+    if (options.maxPolls !== void 0 && polls >= options.maxPolls) return since;
+    await new Promise((resolve) => setTimeout(resolve, options.pollMs ?? POLL_MS));
+  }
+}
+async function readIrtioJsonProject(cwd) {
+  const file = path.join(cwd, "irtio.json");
+  if (!existsSync(file)) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(file, "utf8"));
+  } catch {
+    throw new Error(`irtio logs: ${file} is not valid JSON`);
+  }
+  return typeof parsed.project === "string" && parsed.project.length > 0 ? parsed.project : void 0;
+}
+async function logs(args, deps = {}) {
+  const log = deps.log ?? ((line) => console.log(line));
+  const errorLog = deps.errorLog ?? ((line) => console.error(line));
+  try {
+    const parsed = parseLogsArgs(args);
+    const project = parsed.project ?? await readIrtioJsonProject(process.cwd());
+    if (project === void 0) {
+      throw new Error(
+        "irtio logs: no project id \u2014 pass --project or run this from a project with irtio.json"
+      );
+    }
+    await runLogs({
+      project,
+      follow: parsed.follow,
+      log,
+      ...parsed.since !== void 0 ? { since: parsed.since } : {},
+      ...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 {
+  logs,
+  parseLogsArgs,
+  runLogs
+};

package/dist/migrate-FQIDF747.js

@@ -0,0 +1,206 @@
+import {
+  bundleRoom
+} from "./chunk-ZWCLCYCS.js";
+import {
+  createApiClient,
+  isLoginRequired
+} from "./chunk-J3G6AUJY.js";
+import {
+  resolveControlUrlForUser
+} from "./chunk-UYN5PWLT.js";
+
+// src/migrate.ts
+import { existsSync } from "fs";
+import { mkdir, mkdtemp, readFile, readdir, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import * as path from "path";
+import { pathToFileURL } from "url";
+import {
+  describeType,
+  diffSchemas,
+  schemaFromCanonical
+} from "@irtio/schema";
+import pc from "picocolors";
+var MIGRATIONS_DIR = "irtio/migrations";
+var ROOM_CANDIDATES = ["irtio/room.ts", "irtio/room.js", "room.ts"];
+function parseMigrateArgs(args) {
+  const [sub, name, ...rest] = args;
+  if (sub !== "create") {
+    throw new Error(
+      `irtio migrate: unknown subcommand ${JSON.stringify(sub ?? "")} (expected "create")`
+    );
+  }
+  if (name === void 0 || name.length === 0) {
+    throw new Error(
+      "irtio migrate create: a name is required, e.g. irtio migrate create rename-hp"
+    );
+  }
+  if (rest.length > 0)
+    throw new Error(`irtio migrate create: unexpected extra argument ${JSON.stringify(rest[0])}`);
+  return { command: "create", args: { name } };
+}
+function resolveEntry(cwd, room) {
+  if (room !== void 0) {
+    const file = path.resolve(cwd, room);
+    if (!existsSync(file)) throw new Error(`irtio migrate create: no room file at ${file}`);
+    return file;
+  }
+  for (const candidate of ROOM_CANDIDATES) {
+    const file = path.resolve(cwd, candidate);
+    if (existsSync(file)) return file;
+  }
+  throw new Error(
+    `irtio migrate create: no room file found in ${cwd} (looked for: ${ROOM_CANDIDATES.join(", ")})`
+  );
+}
+async function readIrtioJsonProject(cwd) {
+  const file = path.join(cwd, "irtio.json");
+  if (!existsSync(file)) return void 0;
+  const parsed = JSON.parse(await readFile(file, "utf8"));
+  return typeof parsed.project === "string" && parsed.project.length > 0 ? parsed.project : void 0;
+}
+async function scanDirectoryVersion(cwd) {
+  const dir = path.join(cwd, MIGRATIONS_DIR);
+  if (!existsSync(dir)) return 1;
+  const entries = await readdir(dir);
+  let max = 0;
+  for (const entry of entries) {
+    const match = /^(\d+)_/.exec(entry);
+    if (match) max = Math.max(max, Number(match[1]));
+  }
+  return max + 1;
+}
+function describeSchema(schema) {
+  const lines = [];
+  for (const c of schema.collections) {
+    const fields = c.fields.map((f) => `${f.name}: ${describeType(f.type)}`).join(", ");
+    lines.push(` *   ${c.name}: ${c.kind} { ${fields} }`);
+  }
+  return lines;
+}
+function template(opts) {
+  const breakingLines = opts.breaking.length > 0 ? opts.breaking.map((c) => ` *   - ${c.message}`).join("\n") : " *   (none found \u2014 this migration was scaffolded without a breaking diff to compare against)";
+  const shapeLines = opts.oldShape.length > 0 ? opts.oldShape.join("\n") : " *   (unknown \u2014 no room schema was available when this was scaffolded)";
+  return `/**
+ * Migration to v${opts.version} (from v${opts.fromVersion}).
+ *
+ * Breaking changes to address:
+${breakingLines}
+ *
+ * v${opts.fromVersion}'s shape, for reference (the state \`up\` receives is close to this \u2014 entity
+ * collections arrive as \`{ id: { owner, value } }\`, singletons as the record itself):
+${shapeLines}
+ */
+
+import type { MigrationHelpers, MigrationState } from '@irtio/runtime';
+
+export function up(state: MigrationState, s: MigrationHelpers): MigrationState {
+  // TODO: transform \`state\` from v${opts.fromVersion}'s shape to v${opts.version}'s. \`s.log(...)\`
+  // goes to the room's log; \`state\` is plain data, not the tracked proxy tree \u2014 mutate and
+  // return it, or build and return a new object.
+  return state;
+}
+
+// \`down\` is scaffolded and stored but unused until rollback ships \u2014 uncomment and fill it
+// in if you want it recorded now.
+//
+// export function down(state: MigrationState, s: MigrationHelpers): MigrationState {
+//   return state;
+// }
+`;
+}
+async function runMigrateCreate(options) {
+  const cwd = path.resolve(options.cwd ?? process.cwd());
+  const log = options.log ?? ((line) => console.log(line));
+  const controlUrl = await resolveControlUrlForUser(options.controlUrl);
+  const projectId = options.project ?? await readIrtioJsonProject(cwd);
+  let version;
+  let versionSource;
+  let previousSchemaJson;
+  let client;
+  try {
+    client = options.client ?? await createApiClient(controlUrl);
+    if (projectId === void 0) throw new Error("no project id");
+    const deployments = await client.get(
+      `/v1/projects/${projectId}/deployments`
+    );
+    const latest = deployments.reduce(
+      (best, d) => best === void 0 || d.version > best.version ? d : best,
+      void 0
+    );
+    version = (latest?.version ?? 0) + 1;
+    previousSchemaJson = latest?.schemaJson;
+    versionSource = "control-plane";
+  } catch {
+    version = await scanDirectoryVersion(cwd);
+    versionSource = "directory-scan";
+  }
+  log(
+    pc.dim(
+      `next version: v${version} (from ${versionSource === "control-plane" ? "the control plane" : "scanning irtio/migrations"})`
+    )
+  );
+  const dir = path.join(cwd, MIGRATIONS_DIR);
+  const file = path.join(dir, `${version}_${options.name}.ts`);
+  if (existsSync(file)) {
+    log(pc.yellow(`kept ${path.relative(cwd, file)} (already there \u2014 nothing was overwritten)`));
+    return { file, version, skipped: true, versionSource };
+  }
+  let breaking = [];
+  let oldShape = [];
+  if (previousSchemaJson !== void 0) {
+    try {
+      const entry = resolveEntry(cwd, options.room);
+      const outDir = await mkdtemp(path.join(tmpdir(), "irtio-migrate-"));
+      const result = await bundleRoom({
+        entry,
+        outDir,
+        ...options.irtioPackages !== void 0 ? { irtioPackages: options.irtioPackages } : {}
+      });
+      const mod = await import(pathToFileURL(result.file).href);
+      const oldSchema = schemaFromCanonical(previousSchemaJson);
+      breaking = diffSchemas(oldSchema, mod.default.schema).filter((c) => c.kind === "breaking");
+      oldShape = describeSchema(oldSchema);
+    } catch (err) {
+      log(
+        pc.dim(
+          `(could not compute the live breaking diff: ${err instanceof Error ? err.message : String(err)})`
+        )
+      );
+    }
+  }
+  await mkdir(dir, { recursive: true });
+  const contents = template({ version, fromVersion: version - 1, breaking, oldShape });
+  await writeFile(file, contents, { encoding: "utf8" });
+  log(pc.green(`created ${path.relative(cwd, file)}`));
+  if (breaking.length > 0) {
+    log(pc.dim(`quoted ${breaking.length} breaking change(s) in the header comment`));
+  }
+  return { file, version, skipped: false, versionSource };
+}
+async function migrate(args, deps = {}) {
+  const log = deps.log ?? ((line) => console.log(line));
+  const errorLog = deps.errorLog ?? ((line) => console.error(line));
+  try {
+    const { args: createArgs } = parseMigrateArgs(args);
+    await runMigrateCreate({
+      ...createArgs,
+      log,
+      ...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 {
+  migrate,
+  parseMigrateArgs,
+  runMigrateCreate
+};

package/dist/rooms-JXT3PRHN.js

@@ -0,0 +1,102 @@
+import {
+  createApiClient,
+  isLoginRequired
+} from "./chunk-J3G6AUJY.js";
+import {
+  resolveControlUrlForUser
+} from "./chunk-UYN5PWLT.js";
+
+// src/rooms.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import * as path from "path";
+import pc from "picocolors";
+function parseRoomsArgs(args) {
+  const parsed = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--project": {
+        const value = args[++i];
+        if (value === void 0) throw new Error("irtio rooms: --project needs a value");
+        parsed.project = value;
+        break;
+      }
+      case "--url": {
+        const value = args[++i];
+        if (value === void 0) throw new Error("irtio rooms: --url needs a value");
+        parsed.url = value;
+        break;
+      }
+      default:
+        throw new Error(`irtio rooms: unknown option ${JSON.stringify(arg)}`);
+    }
+  }
+  return parsed;
+}
+function statusColor(status) {
+  return status === "active" || status === "running" ? pc.green(status) : status === "draining" ? pc.yellow(status) : pc.dim(status);
+}
+function formatTable(rows) {
+  if (rows.length === 0) return [pc.dim("no rooms")];
+  const idWidth = Math.max(4, ...rows.map((r) => r.roomId.length));
+  const out = [pc.dim(`${"ROOM".padEnd(idWidth)}  STATUS      LAST SEEN`)];
+  for (const r of rows) {
+    out.push(
+      `${r.roomId.padEnd(idWidth)}  ${statusColor(r.status).padEnd(10)}  ${pc.dim(r.lastSeen)}`
+    );
+  }
+  return out;
+}
+async function runRooms(options) {
+  const log = options.log ?? ((line) => console.log(line));
+  const controlUrl = await resolveControlUrlForUser(options.controlUrl);
+  const client = options.client ?? await createApiClient(controlUrl);
+  const rows = await client.get(`/v1/projects/${options.project}/rooms`);
+  for (const line of formatTable(rows)) log(line);
+  return rows;
+}
+async function readIrtioJsonProject(cwd) {
+  const file = path.join(cwd, "irtio.json");
+  if (!existsSync(file)) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(file, "utf8"));
+  } catch {
+    throw new Error(`irtio rooms: ${file} is not valid JSON`);
+  }
+  return typeof parsed.project === "string" && parsed.project.length > 0 ? parsed.project : void 0;
+}
+async function rooms(args, deps = {}) {
+  const log = deps.log ?? ((line) => console.log(line));
+  const errorLog = deps.errorLog ?? ((line) => console.error(line));
+  try {
+    const parsed = parseRoomsArgs(args);
+    const project = parsed.project ?? await readIrtioJsonProject(process.cwd());
+    if (project === void 0) {
+      throw new Error(
+        "irtio rooms: no project id \u2014 pass --project or run this from a project with irtio.json"
+      );
+    }
+    await runRooms({
+      project,
+      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 {
+  parseRoomsArgs,
+  rooms,
+  runRooms
+};

package/dist/simulate.d.ts

@@ -0,0 +1,62 @@
+import { SimulationReport } from '@irtio/bots';
+import { AnySchema } from '@irtio/schema';
+
+/**
+ * `irtio simulate`: point N real clients at a running room, play it randomly for a few
+ * seconds, and print a pass/fail line per built-in invariant.
+ *
+ * The command is deliberately thin — `@irtio/bots` owns the bots, the trace and the invariants —
+ * and it exists so the agent building a room gets eyes on it from day one, without writing a test
+ * first. Its one real job is loading `irtio/schema.ts` from the project: a schema module is not a
+ * room module, so `bundleRoom` (which insists on a `defineRoom` default export) is the wrong tool
+ * and esbuild is used directly, with the same monorepo aliasing `dev.ts` uses for the worker.
+ *
+ * With no `irtio/schema.ts` the run falls back to a schema-less relay simulation and says so, which
+ * is the honest thing to do: a relay room really does have no schema.
+ */
+
+interface SimulateArgs {
+    bots: number;
+    seconds: number;
+    cheat: boolean;
+    room?: string;
+    url?: string;
+    key?: string;
+    trace?: string;
+}
+/** Hand-rolled, like `parseDevArgs`: the CLI has no argument-parsing dependency. */
+declare function parseSimulateArgs(args: readonly string[]): SimulateArgs;
+interface LoadSchemaOptions {
+    readonly cwd: string;
+    readonly outDir: string;
+    /** Redirects `@irtio/*` for the bundle; the monorepo's own `src/` by default (see `dev.ts`). */
+    readonly irtioPackages?: Record<string, string> | undefined;
+}
+/**
+ * Bundles `irtio/schema.ts` and imports it, returning its `schema` export — or `undefined` when
+ * the project has no schema module at all.
+ */
+declare function loadProjectSchema(options: LoadSchemaOptions): Promise<{
+    schema: AnySchema;
+    file: string;
+} | undefined>;
+interface RunSimulationOptions extends Partial<SimulateArgs> {
+    /** Project root; defaults to `process.cwd()`. */
+    readonly cwd?: string;
+    readonly log?: (line: string) => void;
+    /** @internal Test seam, same as `startDev`'s. */
+    readonly irtioPackages?: Record<string, string> | undefined;
+}
+interface SimulationRun {
+    readonly report: SimulationReport;
+    readonly tracePath: string;
+    /** `false` when there was no schema module and the run fell back to a relay simulation. */
+    readonly schema: boolean;
+    /** Everything that was printed, in order — the same lines `log` received. */
+    readonly output: readonly string[];
+}
+/** The whole command, minus argv parsing and the exit code — tests drive this in-process. */
+declare function runSimulation(options?: RunSimulationOptions): Promise<SimulationRun>;
+declare function simulate(args: readonly string[]): Promise<void>;
+
+export { type LoadSchemaOptions, type RunSimulationOptions, type SimulateArgs, type SimulationRun, loadProjectSchema, parseSimulateArgs, runSimulation, simulate };