@irtio/cli 0.5.1 → 0.6.0

package/dist/delete-project-VENS2B44.js

@@ -0,0 +1,118 @@
+import {
+  HelpRequested,
+  helpFor,
+  helpRequested
+} from "./chunk-ZD4ND6X6.js";
+import {
+  createApiClient,
+  isLoginRequired
+} from "./chunk-RNAH5T4W.js";
+import {
+  resolveControlUrlForUser
+} from "./chunk-UPHQM6NZ.js";
+
+// src/delete-project.ts
+import pc from "picocolors";
+var USAGE = `usage: irtio delete-project <id> --yes [options]
+
+Deletes a project and every record the control plane holds about it: origins, deployments,
+signing secrets, rooms, player KV, leaderboard rows, logs, metrics and usage. This cannot be
+undone. Stored
+objects (bundles, saves, static files) are not deleted here; the platform sweeps orphans later.
+
+A project whose tenant is currently live is refused; wait for its rooms to empty first.
+
+options:
+  --yes              actually delete. Without it the command only prints what would happen
+  --url <control>    control plane (default: your stored login)
+  -h, --help         print this
+`;
+function parseDeleteProjectArgs(args) {
+  if (helpRequested(args)) throw helpFor(USAGE);
+  let project;
+  let yes = false;
+  let url;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--yes":
+        yes = true;
+        break;
+      case "--url": {
+        const value = args[++i];
+        if (value === void 0) throw new Error("irtio delete-project: --url needs a value");
+        url = value;
+        break;
+      }
+      default:
+        if (arg.startsWith("-")) {
+          throw new Error(`irtio delete-project: unknown option ${JSON.stringify(arg)}`);
+        }
+        if (project !== void 0) {
+          throw new Error("irtio delete-project: takes exactly one project id");
+        }
+        project = arg;
+    }
+  }
+  if (project === void 0) {
+    throw new Error(
+      "irtio delete-project: needs a project id \u2014 it is never read from irtio.json, so the wrong directory cannot pick a victim"
+    );
+  }
+  return { project, yes, ...url !== void 0 ? { url } : {} };
+}
+async function runDeleteProject(options) {
+  const log = options.log ?? ((line) => console.log(line));
+  const controlUrl = await resolveControlUrlForUser(options.controlUrl);
+  const client = options.client ?? await createApiClient(controlUrl);
+  const project = await client.get(`/v1/projects/${options.project}`);
+  if (!options.yes) {
+    log(
+      `this would delete project ${pc.bold(project.id)} (${project.name}) and every record of it: origins, deployments, keys, rooms, player KV, leaderboard rows, logs, metrics and usage`
+    );
+    log(pc.dim("nothing was deleted. This cannot be undone once it runs"));
+    log(`to proceed: irtio delete-project ${project.id} --yes`);
+    return false;
+  }
+  await client.del(`/v1/projects/${project.id}`);
+  log(pc.green(`deleted project ${project.id} (${project.name})`));
+  log(
+    pc.dim(
+      "stored objects (bundles, saves, static files) are left for the orphan sweep; nothing serves them any more"
+    )
+  );
+  return true;
+}
+async function deleteProject(args, deps = {}) {
+  const log = deps.log ?? ((line) => console.log(line));
+  const errorLog = deps.errorLog ?? ((line) => console.error(line));
+  try {
+    const parsed = parseDeleteProjectArgs(args);
+    await runDeleteProject({
+      project: parsed.project,
+      yes: parsed.yes,
+      log,
+      ...parsed.url !== void 0 ? { controlUrl: parsed.url } : {},
+      ...deps.client !== void 0 ? { client: deps.client } : {}
+    });
+  } catch (err) {
+    if (err instanceof HelpRequested) {
+      log(err.usage);
+      return;
+    }
+    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 {
+  USAGE,
+  deleteProject,
+  parseDeleteProjectArgs,
+  runDeleteProject
+};

package/dist/deploy.d.ts

@@ -0,0 +1,149 @@
+import { SchemaChange } from '@irtio/schema';
+import { ApiClient } from './api.js';
+import { BundleOptions } from './bundle.js';
+
+/**
+ * `irtio deploy --static <dir>` (week 13, O8/D35): upload a BUILT client directory to the
+ * project's `static/<project>/<version>/` prefix and flip the pointer. No build step — the
+ * developer brings a built directory ("Not in Week 13"). Refuses nothing silently: everything
+ * skipped is named with its reason, and every limit is a named error the caller could have seen
+ * coming (`STATIC_LIMITS`, the week-12 KV-limits shape).
+ */
+
+interface RunStaticDeployResult {
+    readonly project: string;
+    readonly label: string;
+    readonly version: number;
+    readonly files: number;
+    readonly bytes: number;
+    readonly url?: string;
+    /** The origin the deploy added to the project's allow list, when the site has a URL. */
+    readonly origin?: string;
+}
+
+/**
+ * `irtio deploy`: bundle the room, classify the schema change against the last
+ * deployment, refuse anything breaking without a migration, and hand the bundle to the control
+ * plane through the artifact-upload + deployment-create handshake. The CLI never holds storage
+ * credentials — every byte goes up through `POST /v1/projects/:id/artifacts`.
+ *
+ * `bundleRoom` is reused verbatim, including for the migration file: `verify: false` skips
+ * its "default export is a RoomDefinition" check, which a migration module does not satisfy, so
+ * the same import-menu-enforced esbuild path bundles both without any change to `bundle.ts`.
+ * A migration only needs `MigrationState`/`MigrationHelpers` as *types* — `import type { ... }
+ * from '@irtio/runtime'` — which esbuild elides before the resolver plugin ever sees it, so the
+ * `@irtio/server` / `@irtio/schema` import fence is never in the migration author's way.
+ *
+ * `bundleRoom`'s public result deliberately does not expose the canonical schema JSON or the
+ * room's `project` id (`BundleResult` is `file`/`hash`/`schemaHash`/`mode`/`warnings` only), so
+ * once the bundle is verified this module re-imports the file it already wrote to read
+ * `def.schema.project` and `def.schema.canonical` directly, rather than changing `bundleRoom`'s
+ * contract for one caller.
+ */
+
+interface DeployArgs {
+    readonly allowBreaking: boolean;
+    readonly project?: string;
+    readonly url?: string;
+    readonly room?: string;
+    readonly strategy?: 'drain' | 'migrate';
+    readonly name?: string;
+    readonly config?: string;
+    readonly noStatic?: boolean;
+}
+declare const USAGE = "usage: irtio deploy [options]\n       irtio deploy --static [<dir>] [options]\n\nBundles the room, classifies the schema change against the last deployment, and uploads. A\nbreaking change is refused unless a migration covers it. With \"static\" in the project file the\nclient directory ships too, after the room.\n\noptions:\n  --allow-breaking          accept a breaking schema change that a migration covers\n  --strategy drain|migrate  drain (the default) lets running rooms finish on the old version;\n                            migrate moves live rooms onto the new one now\n  --room <file>             the room entry\n  --project <id>            project id (default: the project file)\n  --name <name>             the name a first deploy registers the project under\n  --no-static               deploy the room alone, even with \"static\" configured\n  -c, --config <f>          the project file to read (default irtio.json)\n  --url <control>           control plane (default: your stored login)\n  -h, --help                print this\n\nirtio deploy --static uploads a BUILT client directory and nothing else. It takes --label <label>\nplus --project, --name, --config and --url; the directory and label default to the project file.\n";
+declare function parseDeployArgs(args: readonly string[]): DeployArgs;
+interface RunDeployOptions {
+    readonly cwd?: string;
+    readonly allowBreaking?: boolean;
+    readonly project?: string;
+    /** The name to register a not-yet-existing project under. Otherwise the config file's `name`. */
+    readonly name?: string;
+    /** `-c/--config`: the project file to read, relative to `cwd`. Defaults to `irtio.json`. */
+    readonly config?: string;
+    /** `--no-static`: deploy the room only, leaving a configured static site as it is. */
+    readonly noStatic?: boolean;
+    readonly controlUrl?: string;
+    readonly room?: string;
+    /** Week 13 (D28): `migrate` moves live rooms onto the new version; default `drain`. */
+    readonly strategy?: 'drain' | 'migrate';
+    readonly irtioPackages?: BundleOptions['irtioPackages'];
+    readonly ask?: (question: string) => Promise<string>;
+    readonly log?: (line: string) => void;
+    /** @internal lets tests swap in a client bound to a fixed token instead of the credentials file. */
+    readonly client?: ApiClient;
+}
+interface RunDeployResult {
+    readonly project: string;
+    readonly version: number;
+    readonly url: string;
+    readonly draining: number;
+    readonly applied?: 'live' | 'pending';
+    readonly rooms?: readonly {
+        roomId: string;
+        outcome: string;
+        reason?: string;
+    }[];
+    /** Present when the project file configured a static site and this deploy shipped it too. */
+    readonly site?: RunStaticDeployResult;
+}
+/** The room entry, or undefined when the project has none. `--room` naming a missing file still
+ *  throws: that is a typo, not a project without a room. */
+declare function findRoomEntry(cwd: string, room: string | undefined): string | undefined;
+/** Every room type a project declares, resolved to entry files. */
+interface RoomTypeEntries {
+    /** The entry `resolveEntry` would have picked: what a plain roomId gets. */
+    readonly default: string;
+    /**
+     * Type name -> absolute entry, always including `DEFAULT_ROOM_TYPE`. A project with no
+     * `irtio/rooms/` directory has exactly one member, which is why its deploy is unchanged.
+     */
+    readonly types: Readonly<Record<string, string>>;
+}
+/**
+ * D58: resolve the project's room types.
+ *
+ * The default type is what a plain roomId means, so a project must always name one. `irtio/room.ts`
+ * (the pre-D58 single entry) stays the default when it is there, which is what keeps an existing
+ * project's deploy byte-identical after it grows an `irtio/rooms/` directory; otherwise
+ * `irtio/rooms/default.ts` is it. A project with `irtio/rooms/` and neither is refused rather than
+ * silently deploying types no plain roomId can reach.
+ *
+ * `room` (`--room`) replaces the default type's entry only. Extra types are a project layout fact,
+ * not something a flag naming one file can restate.
+ */
+declare function findRoomTypes(cwd: string, room?: string): RoomTypeEntries;
+/** The whole handshake. Throws on any refusal/error; `deploy()` turns that into exit 1. */
+declare function runDeploy(options?: RunDeployOptions): Promise<RunDeployResult>;
+/**
+ * Distinguishes an intentional refusal (already printed) from an unexpected throw.
+ *
+ * It carries the classification as well as printing it. For the CLI the printed lines are the
+ * whole story, but a non-terminal caller has no terminal to read: `@irtio/mcp` narrates this
+ * refusal into a tool result, and needs the same `changes` and `hint` the control plane's own 409
+ * carries. Without them the most informative failure in the whole deploy path arrives as the
+ * string "deploy refused", which is exactly the shape D40 says a tool result must never be.
+ *
+ * The no-argument form still works, so an older caller keeps compiling.
+ */
+declare class DeployRefusedError extends Error {
+    readonly name = "DeployRefusedError";
+    /** The breaking changes that caused the refusal, as the classifier reported them. */
+    readonly changes: readonly SchemaChange[];
+    /** The remedy, verbatim: normally `run: irtio migrate create <name>`. */
+    readonly hint: string | undefined;
+    constructor(reason?: {
+        changes?: readonly SchemaChange[];
+        hint?: string;
+    });
+}
+/** Thin CLI entry. `deps` is a test seam (log/errorLog capture, an injected client/cwd/aliases). */
+declare function deploy(args: readonly string[], deps?: {
+    log?: (line: string) => void;
+    errorLog?: (line: string) => void;
+    client?: ApiClient;
+    cwd?: string;
+    irtioPackages?: BundleOptions['irtioPackages'];
+}): Promise<void>;
+
+export { type DeployArgs, DeployRefusedError, type RoomTypeEntries, type RunDeployOptions, type RunDeployResult, USAGE, deploy, findRoomEntry, findRoomTypes, parseDeployArgs, runDeploy };