@irtio/cli 0.6.0 → 0.7.0

package/dist/deploy.js

@@ -1,15 +1,15 @@
 import {
   logEnsured,
   runStaticDeploy
-} from "./chunk-3HQMVCYA.js";
+} from "./chunk-BQBOBFBO.js";
 import {
   clientImportsRoom
 } from "./chunk-TQU6345E.js";
-import "./chunk-RQSJZWQC.js";
+import "./chunk-WFMRNGO5.js";
 import {
   ensureProject,
   readProjectConfig
-} from "./chunk-DKWG7MGO.js";
+} from "./chunk-JL235KIE.js";
 import {
   bundleRoom
 } from "./chunk-OTSFRVJN.js";
@@ -17,12 +17,12 @@ import {
   HelpRequested,
   helpFor,
   helpRequested
-} from "./chunk-ZD4ND6X6.js";
+} from "./chunk-OCVALOGK.js";
 import {
   ApiClientError,
   createApiClient,
   isLoginRequired
-} from "./chunk-RNAH5T4W.js";
+} from "./chunk-IDF46P7R.js";
 import {
   resolveControlUrlForUser
 } from "./chunk-UPHQM6NZ.js";
@@ -37,6 +37,7 @@ 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]
@@ -145,12 +146,20 @@ 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`
   );
 }
@@ -235,12 +244,160 @@ 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);
+  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);
@@ -562,6 +719,7 @@ export {
   deploy,
   findRoomEntry,
   findRoomTypes,
+  findSchemaEntry,
   parseDeployArgs,
   runDeploy
 };

package/dist/{dev-QM26ONKS.js → dev-AUZ4OLA3.js}

@@ -23,10 +23,10 @@ import {
   ratingValueProblem,
   saveKey,
   verifyAssertion
-} from "./chunk-RQSJZWQC.js";
+} from "./chunk-WFMRNGO5.js";
 import {
   readProjectConfig
-} from "./chunk-DKWG7MGO.js";
+} from "./chunk-JL235KIE.js";
 import {
   BundleError,
   bundleRoom
@@ -35,8 +35,8 @@ import {
   HelpRequested,
   helpFor,
   helpRequested
-} from "./chunk-ZD4ND6X6.js";
-import "./chunk-RNAH5T4W.js";
+} from "./chunk-OCVALOGK.js";
+import "./chunk-IDF46P7R.js";
 import "./chunk-UPHQM6NZ.js";
 
 // src/dev.ts
@@ -187,9 +187,11 @@ import {
   isMailboxAlarm,
   isOutboxAlarm,
   isRelayHash8,
+  isTypedMsg,
   isVoiceMsg,
   relaySchema as relaySchema2,
   schemaPayload,
+  typedMsgFromClientOk,
   withBuiltins
 } from "@irtio/protocol";
 import { inspectState } from "@irtio/runtime";
@@ -402,10 +404,12 @@ function relayForward(room, peer, type, payload) {
   }
   let target;
   let body;
+  let typed;
   try {
     const msg = decodeMsg(payload);
     target = msg.target;
     body = msg.payload;
+    typed = msg.typed;
   } catch {
     return { ok: false, reason: "malformed MSG" };
   }
@@ -415,7 +419,11 @@ function relayForward(room, peer, type, payload) {
   if (target.kind === "voice") return { ok: true, dropped: true };
   const out = encodeFrame(
     FrameType.MSG,
-    encodeMsg({ target: { kind: "client", clientId: peer.clientId }, payload: body })
+    encodeMsg({
+      target: { kind: "client", clientId: peer.clientId },
+      payload: body,
+      ...typed ? { typed } : {}
+    })
   );
   for (const other of room.peers()) {
     if (other === peer || other.state !== "joined") continue;
@@ -3008,9 +3016,29 @@ var SupervisorImpl = class {
    *
    * They go into a ring under the reserved id `__tenant` (D38), so the whole existing pipeline
    * carries them with no new route and no new frame.
+   *
+   * bug #53 (D67-g, which recorded the gap rather than closing it): on a **sharded** tenant every
+   * ring line is tagged `[shard n]`. Every shard of a project ships its `__tenant` ring under the
+   * same project and the same reserved room id, `log_events` has no shard column, and control
+   * drops the frame's shard before the insert, so without the tag `irtio logs` shows two shards'
+   * boot lines interleaved by time and calls them one restart. The tag is written here, at the
+   * source, because this process is the only thing that knows which shard it is without being
+   * told, and one string in the message beats a schema change on an append-only table.
+   *
+   * It is the mirror of `roomLog` below, and for the same reason: a ring line carries whatever its
+   * stream's identity does not. A room's ring is keyed by the room, so its lines stay bare and the
+   * console gets the `[room]` prefix; the tenant ring is keyed by `__tenant` alone, so its lines
+   * carry the shard and the console stays bare — each shard is its own VM with its own console
+   * file, which already says which shard is talking.
+   *
+   * A single-shard tenant (every tenant that exists today) takes the same bare `args` it always
+   * did, byte for byte: `single-shard-pin.test.ts` holds that.
    */
   log(level, ...args) {
-    this.tenantLogs.push(level, args);
+    this.tenantLogs.push(
+      level,
+      this.isSharded() ? [`[shard ${this.config.shard ?? 0}]`, ...args] : args
+    );
     this.emit(level, args);
   }
   /** The console/config sink, with no ring behind it. */
@@ -3047,9 +3075,20 @@ var SupervisorImpl = class {
    * shape, so a dev tenant's existing snapshots stay readable.
    */
   /**
-   * The read-only admin API the host agent polls from outside the VM (week 5). It exists only
-   * when `adminToken` is configured, and every route is a projection of `SupervisorAdmin` — the
-   * agent must not be able to *change* anything about a tenant it is shipping telemetry for.
+   * The admin API the host agent polls from outside the VM (week 5). It exists only when
+   * `adminToken` is configured.
+   *
+   * Its original rule was that every route is a projection of `SupervisorAdmin` and the agent must
+   * not be able to *change* anything about a tenant it is shipping telemetry for. That rule now
+   * has five exceptions, each added deliberately and each documented at its own `case`:
+   * `/admin/resume` (D31, the post-restore wall clock), `/admin/deploy` (the in-place deploy),
+   * `/admin/caps` (D48), `/admin/identity-keys` (D53), `/admin/bus/deliver` (D67-e) and
+   * `/admin/rooms/evict` (M6 lane A, D68-d). The surviving half of the rule is the part that
+   * matters and it is unchanged: every one of them is a **push from control**, arriving over the
+   * fleet socket and relayed by the agent with the derived admin token. None of them is something
+   * a guest, a tenant or anything else that can reach this port may originate.
+   *
+   * `/admin/rooms/evict` is the one that disconnects players, so it is the one to read carefully.
    */
   serveAdmin(req, res) {
     const token = this.config.adminToken;
@@ -3317,6 +3356,55 @@ var SupervisorImpl = class {
         });
         return true;
       }
+      // ---- M6 lane A: rooms API ----
+      // D68-d: the FIFTH write on this surface, and the only one that disconnects players. A
+      // `DELETE ?force=true` on the rooms API reached control, control authorized it, and this is
+      // control telling the guest to let the room go before the objects are removed underneath it.
+      //
+      // Same `adminToken` gate as every other route here, which is the whole access story: the
+      // token is derived per project from the agent's own fleet token and never leaves the box, so
+      // a tenant cannot forge it, and the frame that triggers this is `ControlToAgent` — a
+      // direction a guest cannot speak on the fleet socket at all.
+      //
+      // Answers `{ outcome }`, never an error for "not here": a room this tenant is not holding is
+      // `absent`, and control deletes the family either way.
+      case "/admin/rooms/evict": {
+        if (req.method !== "POST") {
+          res.writeHead(405, { "content-type": "application/json" });
+          res.end('{"error":"POST only"}');
+          return true;
+        }
+        let body = "";
+        req.on("data", (d) => {
+          body += d.toString();
+        });
+        req.on("end", () => {
+          void (async () => {
+            let parsed;
+            try {
+              parsed = JSON.parse(body || "{}");
+            } catch {
+              res.writeHead(400, { "content-type": "application/json" });
+              res.end('{"error":"body is not JSON"}');
+              return;
+            }
+            if (typeof parsed.roomId !== "string" || parsed.roomId.length === 0) {
+              res.writeHead(400, { "content-type": "application/json" });
+              res.end('{"error":"roomId must be a non-empty string"}');
+              return;
+            }
+            try {
+              json({ outcome: await this.evictRoom(parsed.roomId) });
+            } catch (err) {
+              this.log("error", "admin room evict failed", err);
+              res.writeHead(500, { "content-type": "application/json" });
+              res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+            }
+          })();
+        });
+        return true;
+      }
+      // ---- end M6 lane A ----
       case "/admin/caps": {
         if (req.method === "GET") {
           const state = this.caps.current();
@@ -4403,7 +4491,7 @@ var SupervisorImpl = class {
             message: `${call.playerId} is not a client of room ${room.id}; leaderboard submits are only accepted for players currently in the room`
           };
         }
-        await this.requireLeaderboard().submit(call.board, call.playerId, call.score);
+        await this.requireLeaderboard().submit(call.board, call.playerId, call.score, call.bucket);
         return { ok: true };
       }
       case "ratingReport": {
@@ -5106,6 +5194,43 @@ var SupervisorImpl = class {
     });
     this.roomLog(room, "info", `room closed: ${message}`);
   }
+  // ---- M6 lane A: rooms API ----
+  /**
+   * M6 lane A (D68-d): stop one room and remove its stored keys, because control is about to
+   * delete the rest of its family.
+   *
+   * Answers `'absent'` when this tenant is not holding the room, which is not a failure and is
+   * most of the real cases: the room went to sleep, or this tenant restarted, and control's row
+   * was a poll behind. Control deletes the family either way.
+   *
+   * **The race this exists to close, and why the `await` is the fix.** `closeRoom` already deletes
+   * the live key and the alarm sidecar, and refuses to run twice. What it cannot do on its own is
+   * stop a hibernation that is *already in flight*: by then `hibernateRoom` has read the worker's
+   * snapshot and is inside `putSnapshotWithRetry`, so its `store.put` lands after `closeRoom`'s
+   * `store.delete` and after control's `deleteRoomFamily` — and the room is resurrected as a live
+   * key nothing will ever delete again, because its row is gone, so the reaper cannot see it and
+   * `irtio rooms` cannot list it. Awaiting `room.transition` first removes that window: every path
+   * that can write a snapshot (`hibernateRoom`, `hibernateRelay`, `migrateRoom`, `wakeRoom`)
+   * publishes itself there and settles before the deletes run, and no NEW one can start, because
+   * they all early-return on a state that is not `running` and `closeRoom` has set `closed`.
+   *
+   * The two deletes are awaited, unlike `closeRoom`'s own fire-and-forget pair, for the same
+   * reason: control lists the bucket the instant this answers.
+   *
+   * `flushAll` (tenant idle) needs no guard of its own: `closeRoom` removes the record from the
+   * registry and the flush walks the registry.
+   */
+  async evictRoom(roomId) {
+    const room = this.registry.get(roomId);
+    if (room === void 0) return "absent";
+    await room.transition.catch(() => void 0);
+    this.closeRoom(room, "E_ROOM_DELETED", `room ${roomId} was deleted by an operator`);
+    const key = this.storeKey(room);
+    await this.store.delete(key).catch(() => void 0);
+    await this.store.delete(alarmsKey(key)).catch(() => void 0);
+    return "evicted";
+  }
+  // ---- end M6 lane A ----
   // -------------------------------------------------------------------------
   // Joining
   // -------------------------------------------------------------------------
@@ -5351,6 +5476,9 @@ var SupervisorImpl = class {
       this.handleVoiceFrame(room, session, payload.subarray(1));
       return;
     }
+    if (type === FrameType3.MSG && isTypedMsg(payload) && !typedMsgFromClientOk(payload)) {
+      return;
+    }
     if (room.relay) {
       this.relayFrame(room, session, type, payload);
       return;
@@ -5735,6 +5863,7 @@ var SupervisorImpl = class {
         room.metrics.ticks = stats.ticks;
         room.metrics.maxTickMs = stats.maxTickMs;
         room.metrics.overruns = stats.overruns;
+        room.metrics.messagesDropped = stats.messagesDropped;
         if (msg.heap !== void 0) {
           this.recordHeap(room, msg.heap.usedBytes, msg.heap.limitBytes);
         }

package/dist/index.js

@@ -99,9 +99,21 @@ commands:
        [retire] [--url <control>]                 retire finishes a rotation
   keys jwt-mint --secret <s> --sub <player>       sign a test token locally with the documented
        [--room <id>] [--role <r>] [--ttl <sec>]   recipe \u2014 the secret never leaves this machine
+  rooms [--active|--idle]                         list a project's rooms, with the retention
+        [--idle-longer-than <d>]                  window in force and when each will be deleted
+  rooms get <room>                                one room in full: type, size class, how many
+                                                  saves it holds, how big its state is, deadline
+  rooms set <room> --retention <d|forever|clear>  override the retention window for THIS room
   rooms saves <room>                              list a room's save generations, newest first
   rooms restore <room> --save <id>                bring a room back from a save \u2014 DISCARDS its
                                                   current state; stops the tenant if it is live
+  rooms delete <room> [--force]                   delete a room's stored state. Refused while it
+                                                  is awake unless --force, which disconnects its
+                                                  clients first
+  api-keys mint --scopes <list> [--label <t>]     create a scoped API key for this project and
+                                                  print it once. Scopes: rooms:read, rooms:write
+  api-keys list                                   this project's keys, revoked ones included
+  api-keys revoke <id>                            stop a key working; the row stays as a record
 
 every command takes --help (or -h) and prints its own usage, which is the authority: the lines
 above are a map, and the command's own help is generated next to the code that parses it.
@@ -112,7 +124,8 @@ default location (same as setting IRT_CREDENTIALS_FILE). Sign in once with
 commands \u2014 the pattern for agents and sandboxes that cannot reach the home directory.
 
 every command that reads the project file takes -c/--config <file> to read a different one
-(dev, deploy, deploy --static, migrate create, rollback, logs, rooms, status, keys). Default irtio.json;
+(dev, deploy, deploy --static, migrate create, rollback, logs, rooms, status, keys, api-keys).
+Default irtio.json;
 the named file must exist. That is the test.irtio.json / prod.irtio.json pattern.
 `;
 switch (command) {
@@ -122,7 +135,7 @@ switch (command) {
     break;
   }
   case "dev": {
-    const { dev } = await import("./dev-QM26ONKS.js");
+    const { dev } = await import("./dev-AUZ4OLA3.js");
     await dev(args);
     break;
   }
@@ -132,18 +145,18 @@ switch (command) {
     break;
   }
   case "login": {
-    const { login } = await import("./login-2M73HBZT.js");
+    const { login } = await import("./login-3RVN5PPN.js");
     await login(args);
     break;
   }
   case "whoami": {
-    const { whoami } = await import("./whoami-KTMTQNHM.js");
+    const { whoami } = await import("./whoami-UFSWPWK6.js");
     await whoami(args);
     break;
   }
   case "deploy": {
     if (args.includes("--static")) {
-      const { staticDeploy } = await import("./static-deploy-KOWFKWZA.js");
+      const { staticDeploy } = await import("./static-deploy-7UCYINJB.js");
       await staticDeploy(args);
       break;
     }
@@ -152,52 +165,63 @@ switch (command) {
     break;
   }
   case "migrate": {
-    const { migrate } = await import("./migrate-T3DZJREY.js");
+    const { migrate } = await import("./migrate-FMXTRVUV.js");
     await migrate(args);
     break;
   }
   case "rollback": {
-    const { rollback } = await import("./rollback-SO74MVZV.js");
+    const { rollback } = await import("./rollback-LI4TDLQA.js");
     await rollback(args);
     break;
   }
   case "keys": {
-    const { keys } = await import("./keys-JHLMEGRA.js");
+    const { keys } = await import("./keys-NXRIBJZP.js");
     await keys(args);
     break;
   }
+  // ---- M6 lane A: rooms API ----
+  // Deliberately not folded into `keys` above: that one manages the HMAC secret a game signs its
+  // own player tokens with, and this one manages a credential a developer's backend authenticates
+  // to irtio with. Two ideas, two names, so "rotate my signing secret" is never one typo away
+  // from "revoke my cron job's key".
+  case "api-keys": {
+    const { apiKeys } = await import("./api-keys-UTLYMZYN.js");
+    await apiKeys(args);
+    break;
+  }
+  // ---- end M6 lane A ----
   case "logs": {
-    const { logs } = await import("./logs-2W7CPZO5.js");
+    const { logs } = await import("./logs-AT7G6YRH.js");
     await logs(args);
     break;
   }
   case "rooms": {
-    const { rooms } = await import("./rooms-VI33P4RA.js");
+    const { rooms } = await import("./rooms-52Q5KBUS.js");
     await rooms(args);
     break;
   }
   case "status": {
-    const { status } = await import("./status-HF3ZEKB7.js");
+    const { status } = await import("./status-JZGKH2P6.js");
     await status(args);
     break;
   }
   case "delete-project": {
-    const { deleteProject } = await import("./delete-project-VENS2B44.js");
+    const { deleteProject } = await import("./delete-project-MXUYNGAO.js");
     await deleteProject(args);
     break;
   }
   case "usage": {
-    const { usage } = await import("./usage-4G23QXCH.js");
+    const { usage } = await import("./usage-7S447INI.js");
     await usage(args);
     break;
   }
   case "ratings": {
-    const { ratings } = await import("./ratings-VG32WFDG.js");
+    const { ratings } = await import("./ratings-XBLX2MUW.js");
     await ratings(args);
     break;
   }
   case "leaderboard": {
-    const { leaderboard } = await import("./leaderboard-SYPSBPS3.js");
+    const { leaderboard } = await import("./leaderboard-ZBJBKETM.js");
     await leaderboard(args);
     break;
   }

package/dist/init.js

@@ -2,8 +2,8 @@ import {
   HelpRequested,
   helpFor,
   helpRequested
-} from "./chunk-ZD4ND6X6.js";
-import "./chunk-RNAH5T4W.js";
+} from "./chunk-OCVALOGK.js";
+import "./chunk-IDF46P7R.js";
 import "./chunk-UPHQM6NZ.js";
 
 // src/init.ts

package/dist/{keys-JHLMEGRA.js → keys-NXRIBJZP.js}

@@ -1,13 +1,13 @@
 import {
   readProjectConfig
-} from "./chunk-DKWG7MGO.js";
+} from "./chunk-JL235KIE.js";
 import {
   helpRequested
-} from "./chunk-ZD4ND6X6.js";
+} from "./chunk-OCVALOGK.js";
 import {
   createApiClient,
   isLoginRequired
-} from "./chunk-RNAH5T4W.js";
+} from "./chunk-IDF46P7R.js";
 import {
   resolveControlUrlForUser
 } from "./chunk-UPHQM6NZ.js";