@irtio/cli 0.5.2 → 0.7.0

package/dist/{deploy-3SABPL3T.js → deploy.js}

@@ -1,38 +1,45 @@
-import {
-  clientImportsRoom
-} from "./chunk-TQU6345E.js";
-import {
-  bundleRoom
-} from "./chunk-KRQUAEN2.js";
 import {
   logEnsured,
   runStaticDeploy
-} from "./chunk-GBNHBWES.js";
-import "./chunk-BPE452KF.js";
+} from "./chunk-BQBOBFBO.js";
+import {
+  clientImportsRoom
+} from "./chunk-TQU6345E.js";
+import "./chunk-WFMRNGO5.js";
 import {
   ensureProject,
   readProjectConfig
-} from "./chunk-32QTPKVT.js";
+} from "./chunk-JL235KIE.js";
+import {
+  bundleRoom
+} from "./chunk-OTSFRVJN.js";
 import {
-  ApiClientError,
   HelpRequested,
-  createApiClient,
   helpFor,
-  helpRequested,
-  isLoginRequired,
+  helpRequested
+} from "./chunk-OCVALOGK.js";
+import {
+  ApiClientError,
+  createApiClient,
+  isLoginRequired
+} from "./chunk-IDF46P7R.js";
+import {
   resolveControlUrlForUser
-} from "./chunk-TV66QHFP.js";
+} from "./chunk-UPHQM6NZ.js";
 
 // src/deploy.ts
-import { existsSync } from "fs";
+import { existsSync, readdirSync } from "fs";
 import { mkdir, readFile, readdir, rm } from "fs/promises";
 import * as path from "path";
 import { createInterface } from "readline/promises";
 import { pathToFileURL } from "url";
+import { DEFAULT_ROOM_TYPE, ROOM_TYPE_RE } from "@irtio/protocol";
 import { diffSchemas, schemaFromCanonical } from "@irtio/schema";
 import pc from "picocolors";
 var ROOM_CANDIDATES = ["irtio/room.ts", "irtio/room.js", "room.ts"];
+var SCHEMA_CANDIDATES = ["irtio/schema.ts", "irtio/schema.js"];
 var MIGRATIONS_DIR = "irtio/migrations";
+var ROOM_TYPES_DIR = "irtio/rooms";
 var USAGE = `usage: irtio deploy [options]
        irtio deploy --static [<dir>] [options]
 
@@ -139,15 +146,62 @@ function findRoomEntry(cwd, room) {
   }
   return void 0;
 }
+function findSchemaEntry(cwd) {
+  for (const candidate of SCHEMA_CANDIDATES) {
+    const file = path.resolve(cwd, candidate);
+    if (existsSync(file)) return file;
+  }
+  return void 0;
+}
 function resolveEntry(cwd, room) {
   const entry = findRoomEntry(cwd, room);
   if (entry !== void 0) return entry;
   throw new Error(
     `irtio deploy: no room file found in ${cwd}
   looked for: ${ROOM_CANDIDATES.join(", ")}
+  or ${SCHEMA_CANDIDATES.join(" / ")}, to deploy a schema with no room code
   pass --room <file> if it lives elsewhere`
   );
 }
+function findRoomTypes(cwd, room) {
+  const dir = path.resolve(cwd, ROOM_TYPES_DIR);
+  const types = {};
+  if (existsSync(dir)) {
+    for (const name of readdirSync(dir).sort()) {
+      const ext = path.extname(name);
+      if (ext !== ".ts" && ext !== ".js") continue;
+      const type = name.slice(0, -ext.length);
+      if (!ROOM_TYPE_RE.test(type)) {
+        throw new Error(
+          `irtio deploy: ${path.join(ROOM_TYPES_DIR, name)} is not a usable room type name
+  a type name is lowercase letters, digits, "_" or "-", starting with a letter or digit, at most 24 characters
+  rename the file, or move it out of ${ROOM_TYPES_DIR}/ if it is not a room entry`
+        );
+      }
+      types[type] = path.join(dir, name);
+    }
+  }
+  const explicit = findRoomEntry(cwd, room);
+  if (explicit !== void 0) {
+    if (room === void 0 && types[DEFAULT_ROOM_TYPE] !== void 0) {
+      throw new Error(
+        `irtio deploy: this project names its default room type twice, in ${ROOM_CANDIDATES[0]} and in ${ROOM_TYPES_DIR}/default.ts
+  keep one of them: a plain roomId resolves to exactly one definition`
+      );
+    }
+    return { default: explicit, types: { ...types, [DEFAULT_ROOM_TYPE]: explicit } };
+  }
+  const fallback = types[DEFAULT_ROOM_TYPE];
+  if (fallback !== void 0) return { default: fallback, types };
+  if (Object.keys(types).length > 0) {
+    throw new Error(
+      `irtio deploy: ${ROOM_TYPES_DIR}/ declares ${Object.keys(types).join(", ")} but no default room type, and a roomId with no type prefix has to resolve to one
+  add ${ROOM_TYPES_DIR}/default.ts, or keep the single entry at ${ROOM_CANDIDATES[0]}`
+    );
+  }
+  const entry = resolveEntry(cwd, room);
+  return { default: entry, types: { [DEFAULT_ROOM_TYPE]: entry } };
+}
 async function warnIfClientImportsRoom(cwd, entry, config, log) {
   const client = config.client;
   if (client === void 0) return;
@@ -162,10 +216,17 @@ async function warnIfClientImportsRoom(cwd, entry, config, log) {
 }
 async function loadBundledSchema(file) {
   const mod = await import(pathToFileURL(file).href);
+  const config = mod.default.config;
   return {
     project: mod.default.schema.project,
     canonical: mod.default.schema.canonical,
-    schema: mod.default.schema
+    schema: mod.default.schema,
+    memoryMb: typeof config?.memoryMb === "number" ? config.memoryMb : void 0,
+    maxAwake: typeof config?.maxAwake === "number" ? config.maxAwake : void 0,
+    // The declared string, verbatim and unparsed. `defineRoom` already refused anything the
+    // grammar does not accept, and control refuses it again; the CLI's job is to carry what the
+    // bundle says rather than to have an opinion of its own about a duration.
+    retention: typeof config?.retention === "string" ? config.retention : void 0
   };
 }
 function printBreaking(log, breaking, hint) {
@@ -183,13 +244,162 @@ async function findMigrationFile(cwd, version) {
   return match ? path.join(dir, match) : void 0;
 }
 var DEPLOY_BUILD_DIR = path.join(".irtio", "deploy");
+function isSchemaOnly(cwd, room) {
+  if (room !== void 0) return false;
+  if (findRoomEntry(cwd, void 0) !== void 0) return false;
+  if (existsSync(path.resolve(cwd, ROOM_TYPES_DIR))) return false;
+  return findSchemaEntry(cwd) !== void 0;
+}
+async function loadDeployedSchema(entry, outDir, irtioPackages) {
+  const bundled = await bundleRoom({
+    entry,
+    outDir,
+    verify: false,
+    ...irtioPackages !== void 0 ? { irtioPackages } : {}
+  });
+  const mod = await import(pathToFileURL(bundled.file).href);
+  const schema = mod.schema ?? mod.default;
+  if (!schema || typeof schema.canonical !== "string" || typeof schema.hash !== "string") {
+    throw new Error(
+      `irtio deploy: ${path.basename(entry)} does not export a schema
+  it must export the value defineSchema(...) returned, as \`schema\` or as the default`
+    );
+  }
+  return schema;
+}
+async function runSchemaOnlyDeploy(options, cwd, log, ask, controlUrl, config) {
+  const entry = findSchemaEntry(cwd);
+  const outDir = path.join(cwd, DEPLOY_BUILD_DIR);
+  await mkdir(outDir, { recursive: true });
+  const schema = await loadDeployedSchema(entry, outDir, options.irtioPackages);
+  log(pc.green(`bundled ${path.relative(cwd, entry)} (schema ${schema.hash.slice(0, 12)})`));
+  const client = options.client ?? await createApiClient(controlUrl);
+  const projectId = options.project ?? config.project ?? schema.project;
+  if (projectId === void 0) {
+    throw new Error(
+      'irtio deploy: no project id \u2014 pass --project, add "project" to irtio.json, or set it in defineSchema(...)'
+    );
+  }
+  const ensured = await ensureProject(client, projectId, {
+    cwd,
+    config,
+    command: "irtio deploy",
+    ...options.name !== void 0 ? { name: options.name } : {}
+  });
+  logEnsured(log, projectId, ensured);
+  const deployments = await client.get(`/v1/projects/${projectId}/deployments`);
+  const newestOf = (list) => list.reduce(
+    (best, d) => best === void 0 || d.version > best.version ? d : best,
+    void 0
+  );
+  const previous = newestOf(deployments.filter((d) => d.rolledBackAt == null));
+  const newest = newestOf(deployments);
+  const nextVersion = (newest?.version ?? 0) + 1;
+  let allowBreaking = options.allowBreaking ?? false;
+  let migrationFile;
+  if (previous !== void 0) {
+    const changes = diffSchemas(schemaFromCanonical(previous.schemaJson), schema);
+    const breaking = changes.filter((c) => c.kind === "breaking");
+    const additive = changes.filter((c) => c.kind === "additive");
+    if (breaking.length > 0) {
+      if (!allowBreaking) {
+        const hint = "run: irtio migrate create <name>";
+        printBreaking(log, breaking, hint);
+        throw new DeployRefusedError({ changes: breaking, hint });
+      }
+      migrationFile = await findMigrationFile(cwd, nextVersion);
+      if (migrationFile === void 0) {
+        const hint = `--allow-breaking needs a migration for v${nextVersion}. Run: irtio migrate create <name>`;
+        printBreaking(log, breaking, hint);
+        throw new DeployRefusedError({ changes: breaking, hint });
+      }
+      log(pc.yellow(`${breaking.length} breaking change(s), proceeding with --allow-breaking:`));
+      for (const change of breaking) log(`  ${change.message}`);
+    } else {
+      allowBreaking = false;
+    }
+    if (additive.length > 0) {
+      log(pc.cyan(`${additive.length} additive change(s):`));
+      for (const change of additive) log(`  ${change.message}`);
+    }
+    if (changes.length === 0) log(pc.dim("no schema changes"));
+  } else {
+    log(pc.dim("no previous deployment, so this is the first deploy for this project"));
+  }
+  let migrationKey;
+  if (migrationFile !== void 0) {
+    const migrationBundle = await bundleRoom({
+      entry: migrationFile,
+      outDir,
+      verify: false,
+      ...options.irtioPackages !== void 0 ? { irtioPackages: options.irtioPackages } : {}
+    });
+    const uploaded = await client.postBytes(
+      `/v1/projects/${projectId}/artifacts`,
+      new Uint8Array(await readFile(migrationBundle.file))
+    );
+    migrationKey = uploaded.key;
+    log(pc.green(`bundled and uploaded migration ${path.basename(migrationFile)}`));
+  }
+  let origin;
+  if (previous === void 0) {
+    const answer = (await ask("production origin (localhost is always allowed) \u2014 leave blank to skip: ")).trim();
+    if (answer.length > 0) origin = answer;
+  }
+  let created;
+  try {
+    created = await client.post(`/v1/projects/${projectId}/deployments`, {
+      // No `bundleHash` and no `bundleKey`: that absence IS the schema-only deploy, and it is
+      // what makes control write a row `isRelayOnly` reads as relay-only.
+      schemaJson: schema.canonical,
+      schemaHash: schema.hash,
+      ...migrationKey !== void 0 ? { migrationKey } : {},
+      ...allowBreaking ? { allowBreaking: true } : {},
+      ...origin !== void 0 ? { origin } : {}
+    });
+  } catch (err) {
+    if (err instanceof ApiClientError && err.code === "E_BREAKING_SCHEMA" && err.changes) {
+      const changes = err.changes;
+      const hint = err.hint ?? "run: irtio migrate create <name>";
+      printBreaking(log, changes, hint);
+      throw new DeployRefusedError({ changes, hint });
+    }
+    if (isLoginRequired(err)) throw err;
+    throw err;
+  }
+  await rm(outDir, { recursive: true, force: true }).catch(() => {
+  });
+  log(pc.green(`deployed v${created.version}`));
+  log(pc.dim("schema-only deploy: this project runs as a relay tenant"));
+  log(pc.dim(`reachable at ${created.url}`));
+  const result = {
+    project: projectId,
+    version: created.version,
+    url: created.url,
+    draining: created.draining,
+    ...created.applied !== void 0 ? { applied: created.applied } : {}
+  };
+  if (config.static === void 0 || options.noStatic === true) return result;
+  const site = await runStaticDeploy({
+    cwd,
+    ...options.config !== void 0 ? { config: options.config } : {},
+    ...options.controlUrl !== void 0 ? { controlUrl: options.controlUrl } : {},
+    ...options.client !== void 0 ? { client: options.client } : {},
+    log
+  });
+  return { ...result, site };
+}
 async function runDeploy(options = {}) {
   const cwd = path.resolve(options.cwd ?? process.cwd());
   const log = options.log ?? ((line) => console.log(line));
   const ask = options.ask ?? defaultAsk;
   const controlUrl = await resolveControlUrlForUser(options.controlUrl);
   const config = await readProjectConfig(cwd, "irtio deploy", options.config);
-  const entry = resolveEntry(cwd, options.room);
+  if (isSchemaOnly(cwd, options.room)) {
+    return runSchemaOnlyDeploy(options, cwd, log, ask, controlUrl, config);
+  }
+  const roomTypes = findRoomTypes(cwd, options.room);
+  const entry = roomTypes.default;
   await warnIfClientImportsRoom(cwd, entry, config, log);
   const outDir = path.join(cwd, DEPLOY_BUILD_DIR);
   await mkdir(outDir, { recursive: true });
@@ -228,25 +438,25 @@ async function runDeploy(options = {}) {
   const newest = newestOf(deployments);
   let allowBreaking = options.allowBreaking ?? false;
   let migrationFile;
+  let schemaChange = "none";
   const nextVersion = (newest?.version ?? 0) + 1;
   if (previous !== void 0) {
     const oldSchema = schemaFromCanonical(previous.schemaJson);
     const changes = diffSchemas(oldSchema, bundled.schema);
     const breaking = changes.filter((c) => c.kind === "breaking");
     const additive = changes.filter((c) => c.kind === "additive");
+    schemaChange = breaking.length > 0 ? "breaking" : additive.length > 0 ? "additive" : "none";
     if (breaking.length > 0) {
       if (!allowBreaking) {
-        printBreaking(log, breaking, "run: irtio migrate create <name>");
-        throw new DeployRefusedError();
+        const hint = "run: irtio migrate create <name>";
+        printBreaking(log, breaking, hint);
+        throw new DeployRefusedError({ changes: breaking, hint });
       }
       migrationFile = await findMigrationFile(cwd, nextVersion);
       if (migrationFile === void 0) {
-        printBreaking(
-          log,
-          breaking,
-          `--allow-breaking needs a migration for v${nextVersion} \u2014 run: irtio migrate create <name>`
-        );
-        throw new DeployRefusedError();
+        const hint = `--allow-breaking needs a migration for v${nextVersion}. Run: irtio migrate create <name>`;
+        printBreaking(log, breaking, hint);
+        throw new DeployRefusedError({ changes: breaking, hint });
       }
       log(pc.yellow(`${breaking.length} breaking change(s), proceeding with --allow-breaking:`));
       for (const change of breaking) log(`  ${change.message}`);
@@ -259,7 +469,7 @@ async function runDeploy(options = {}) {
     }
     if (changes.length === 0) log(pc.dim("no schema changes"));
   } else {
-    log(pc.dim("no previous deployment \u2014 first deploy for this project"));
+    log(pc.dim("no previous deployment, so this is the first deploy for this project"));
   }
   let migrationKey;
   if (migrationFile !== void 0) {
@@ -283,6 +493,45 @@ async function runDeploy(options = {}) {
     roomBytes
   );
   log(pc.green("uploaded bundle"));
+  const extraRooms = {};
+  for (const [type, typeEntry] of Object.entries(roomTypes.types)) {
+    if (type === DEFAULT_ROOM_TYPE) continue;
+    let typeResult;
+    try {
+      typeResult = await bundleRoom({
+        entry: typeEntry,
+        outDir,
+        ...options.irtioPackages !== void 0 ? { irtioPackages: options.irtioPackages } : {}
+      });
+    } catch (err) {
+      throw new Error(
+        `irtio deploy: room type "${type}": ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    if (typeResult.schemaHash === void 0) {
+      throw new Error(`irtio deploy: room type "${type}" bundled without a schema hash`);
+    }
+    const typeSchema = await loadBundledSchema(typeResult.file);
+    const uploaded = await client.postBytes(
+      `/v1/projects/${projectId}/artifacts`,
+      new Uint8Array(await readFile(typeResult.file))
+    );
+    extraRooms[type] = {
+      bundleHash: typeResult.hash,
+      bundleKey: uploaded.key,
+      schemaJson: typeSchema.canonical,
+      schemaHash: typeResult.schemaHash,
+      // M5 part 3.5: this type's sizing declarations travel with its bundle, so control and the
+      // host agent can size the VM before it boots. Spread, never null: a type that declares
+      // neither sends neither, and the env generation of a project that has never declared
+      // anything is unchanged.
+      ...typeSchema.memoryMb !== void 0 ? { memoryMb: typeSchema.memoryMb } : {},
+      ...typeSchema.maxAwake !== void 0 ? { maxAwake: typeSchema.maxAwake } : {},
+      ...typeSchema.retention !== void 0 ? { retention: typeSchema.retention } : {}
+    };
+    log(pc.green(`bundled and uploaded room type ${type} (${typeResult.hash.slice(0, 12)})`));
+  }
+  const hasExtraTypes = Object.keys(extraRooms).length > 0;
   let origin;
   if (previous === void 0) {
     const answer = (await ask("production origin (localhost is always allowed) \u2014 leave blank to skip: ")).trim();
@@ -290,17 +539,35 @@ async function runDeploy(options = {}) {
   }
   const strategy = options.strategy ?? "drain";
   if (strategy === "migrate") {
-    log(pc.yellow("strategy: migrate \u2014 live rooms move onto the new version now."));
-    log(
-      pc.yellow(
-        "Schema unchanged: connected clients see a short gap and a resync on the same socket."
-      )
-    );
-    log(
-      pc.yellow(
-        "Schema changed at all: EVERY connected client is disconnected with E_SCHEMA_MISMATCH and must reload."
-      )
+    log(pc.yellow("strategy: migrate. Live rooms move onto the new version now."));
+    const physics = bundled.schema.collections.some(
+      (c) => c.physics !== void 0
     );
+    if (schemaChange === "breaking") {
+      log(
+        pc.yellow(
+          "Breaking schema change: EVERY connected client is disconnected with E_SCHEMA_MISMATCH and must reload."
+        )
+      );
+    } else {
+      log(
+        pc.yellow(
+          schemaChange === "none" ? "Schema unchanged: connected clients see a short gap and a resync on the same socket." : "Additive schema change: connected clients see a short gap and a resync on the same socket, on the new schema."
+        )
+      );
+      if (physics) {
+        log(
+          pc.yellow(
+            "This schema has physics collections. A change touching one of those is treated as breaking for now, so those clients reload."
+          )
+        );
+      }
+      log(
+        pc.dim(
+          "Clients built before irtio 0.6 are still disconnected with E_SCHEMA_MISMATCH on any schema change."
+        )
+      );
+    }
   }
   let response;
   try {
@@ -309,6 +576,13 @@ async function runDeploy(options = {}) {
       bundleKey: uploadedRoom.key,
       schemaJson: bundled.canonical,
       schemaHash: result.schemaHash,
+      // M5 part 3.5: the default type's declarations, top-level beside its schema for the reason
+      // `DeploymentSpec` states — the default type is not in the `rooms` map, and putting it there
+      // would give every single-room project a `rooms` key and cold-boot the fleet.
+      ...bundled.memoryMb !== void 0 ? { memoryMb: bundled.memoryMb } : {},
+      ...bundled.maxAwake !== void 0 ? { maxAwake: bundled.maxAwake } : {},
+      ...bundled.retention !== void 0 ? { retention: bundled.retention } : {},
+      ...hasExtraTypes ? { rooms: extraRooms } : {},
       ...migrationKey !== void 0 ? { migrationKey } : {},
       ...allowBreaking ? { allowBreaking: true } : {},
       ...origin !== void 0 ? { origin } : {},
@@ -324,12 +598,10 @@ async function runDeploy(options = {}) {
     };
   } catch (err) {
     if (err instanceof ApiClientError && err.code === "E_BREAKING_SCHEMA" && err.changes) {
-      printBreaking(
-        log,
-        err.changes,
-        err.hint ?? "run: irtio migrate create <name>"
-      );
-      throw new DeployRefusedError();
+      const changes = err.changes;
+      const hint = err.hint ?? "run: irtio migrate create <name>";
+      printBreaking(log, changes, hint);
+      throw new DeployRefusedError({ changes, hint });
     }
     throw err;
   }
@@ -376,8 +648,14 @@ async function runDeploy(options = {}) {
 }
 var DeployRefusedError = class extends Error {
   name = "DeployRefusedError";
-  constructor() {
+  /** The breaking changes that caused the refusal, as the classifier reported them. */
+  changes;
+  /** The remedy, verbatim: normally `run: irtio migrate create <name>`. */
+  hint;
+  constructor(reason = {}) {
     super("deploy refused");
+    this.changes = reason.changes ?? [];
+    this.hint = reason.hint;
   }
 };
 async function deploy(args, deps = {}) {
@@ -388,7 +666,7 @@ async function deploy(args, deps = {}) {
     const cwd = path.resolve(deps.cwd ?? process.cwd());
     const config = await readProjectConfig(cwd, "irtio deploy", parsed.config);
     if (parsed.room === void 0 && parsed.noStatic !== true && config.static !== void 0 && findRoomEntry(cwd, void 0) === void 0) {
-      log(pc.dim("no room file \u2014 deploying the static site only"));
+      log(pc.dim("no room file, so deploying the static site only"));
       await runStaticDeploy({
         cwd,
         log,
@@ -440,6 +718,8 @@ export {
   USAGE,
   deploy,
   findRoomEntry,
+  findRoomTypes,
+  findSchemaEntry,
   parseDeployArgs,
   runDeploy
 };