@irtio/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 irtio contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/bundle.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The deploy artifact builder: one ESM file from the room entry, import menu enforced by a
+ * resolver plugin, content hash over the output + canonical schema, verified by loading the
+ * bundle in a worker and checking the default export is a RoomDefinition.
+ */
+/** Bare imports room code may use. Everything else (including node:*) is rejected. */
+declare const ALLOWED_IMPORTS: string[];
+interface BundleOptions {
+    /** The room entry file (must `export default defineRoom(...)`). */
+    readonly entry: string;
+    readonly outDir: string;
+    /**
+     * Where the allowed packages resolve from. Defaults to normal node resolution relative to the
+     * entry; the monorepo's tests point these at sibling `src/index.ts` files.
+     */
+    readonly irtioPackages?: Partial<Record<(typeof ALLOWED_IMPORTS)[number], string>>;
+    /** Skip the load-in-worker verification (used by watch rebuilds after the first success). */
+    readonly verify?: boolean;
+}
+interface BundleResult {
+    /** Absolute path of the bundled file (`room.<hash8>.mjs`). */
+    readonly file: string;
+    /** sha256(output + canonical schema), hex. Identifies the deployment version. */
+    readonly hash: string;
+    /** The builder schema hash from the definition (undefined when verify: false). */
+    readonly schemaHash?: string;
+    readonly mode?: 'tick' | 'event';
+    readonly warnings: readonly string[];
+}
+declare class BundleError extends Error {
+    readonly name = "BundleError";
+}
+/** Bundles the room entry; throws `BundleError` with the esbuild message on failure. */
+declare function bundleRoom(options: BundleOptions): Promise<BundleResult>;
+
+export { ALLOWED_IMPORTS, BundleError, type BundleOptions, type BundleResult, bundleRoom };

package/dist/bundle.js

@@ -0,0 +1,10 @@
+import {
+  ALLOWED_IMPORTS,
+  BundleError,
+  bundleRoom
+} from "./chunk-ZWCLCYCS.js";
+export {
+  ALLOWED_IMPORTS,
+  BundleError,
+  bundleRoom
+};

package/dist/chunk-J3G6AUJY.js

@@ -0,0 +1,85 @@
+import {
+  readCredential
+} from "./chunk-UYN5PWLT.js";
+
+// src/api-client.ts
+var ApiClientError = class extends Error {
+  name = "ApiClientError";
+  status;
+  code;
+  changes;
+  hint;
+  constructor(status, body) {
+    super(body.message);
+    this.status = status;
+    this.code = body.code;
+    this.changes = body.changes;
+    this.hint = body.hint;
+  }
+};
+var NotLoggedInError = class extends Error {
+  constructor(controlUrl) {
+    super(`not logged in to ${controlUrl} \u2014 run: irtio login`);
+    this.controlUrl = controlUrl;
+  }
+  controlUrl;
+  name = "NotLoggedInError";
+};
+async function createApiClient(controlUrl) {
+  const credential = await readCredential(controlUrl);
+  if (!credential) throw new NotLoggedInError(controlUrl);
+  return createApiClientWithToken(controlUrl, credential.token);
+}
+function createApiClientWithToken(controlUrl, token) {
+  async function request(method, path, init = {}) {
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json"
+    };
+    let requestBody;
+    if (init.bytes !== void 0) {
+      headers["content-type"] = "application/octet-stream";
+      requestBody = init.bytes;
+    } else if (init.body !== void 0) {
+      headers["content-type"] = "application/json";
+      requestBody = JSON.stringify(init.body);
+    }
+    const response = await fetch(`${controlUrl}${path}`, {
+      method,
+      headers,
+      ...requestBody !== void 0 ? { body: requestBody } : {}
+    });
+    const text = await response.text();
+    const parsed = text.length > 0 ? JSON.parse(text) : void 0;
+    if (!response.ok) {
+      const body = parsed !== void 0 && typeof parsed === "object" && parsed !== null && "code" in parsed && "message" in parsed ? parsed : {
+        code: "E_UNKNOWN",
+        message: text || `${method} ${path} failed with ${response.status}`
+      };
+      throw new ApiClientError(response.status, body);
+    }
+    return parsed;
+  }
+  return {
+    controlUrl,
+    get(path, query) {
+      const qs = query ? Object.entries(query).filter((e) => e[1] !== void 0).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&") : "";
+      return request("GET", qs ? `${path}?${qs}` : path);
+    },
+    post(path, body) {
+      return request("POST", path, { body });
+    },
+    postBytes(path, bytes) {
+      return request("POST", path, { bytes });
+    }
+  };
+}
+function isLoginRequired(err) {
+  return err instanceof NotLoggedInError || err instanceof ApiClientError && err.status === 401;
+}
+
+export {
+  ApiClientError,
+  createApiClient,
+  isLoginRequired
+};

package/dist/chunk-UYN5PWLT.js

@@ -0,0 +1,59 @@
+// src/credentials.ts
+import { existsSync } from "fs";
+import { chmod, mkdir, readFile, writeFile } from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+function credentialsPath() {
+  if (process.env.IRT_CREDENTIALS_FILE) return process.env.IRT_CREDENTIALS_FILE;
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+    return path.join(appData, "irtio", "credentials.json");
+  }
+  return path.join(os.homedir(), ".config", "irtio", "credentials.json");
+}
+async function readCredentials() {
+  const file = credentialsPath();
+  if (!existsSync(file)) return {};
+  try {
+    const raw = await readFile(file, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+async function readCredential(controlUrl) {
+  const all = await readCredentials();
+  return all[controlUrl];
+}
+async function writeCredential(controlUrl, credential) {
+  const file = credentialsPath();
+  await mkdir(path.dirname(file), { recursive: true });
+  const all = await readCredentials();
+  all[controlUrl] = credential;
+  await writeFile(file, `${JSON.stringify(all, null, 2)}
+`, { mode: 384 });
+  await chmod(file, 384).catch(() => {
+  });
+  return file;
+}
+var DEFAULT_CONTROL_URL = "https://control.irt.io";
+function resolveControlUrl(flag) {
+  return flag ?? process.env.IRT_CONTROL_URL ?? DEFAULT_CONTROL_URL;
+}
+async function resolveControlUrlForUser(flag) {
+  const explicit = flag ?? process.env.IRT_CONTROL_URL;
+  if (explicit !== void 0) return explicit;
+  const all = await readCredentials();
+  const urls = Object.keys(all);
+  return urls.length === 1 ? urls[0] : DEFAULT_CONTROL_URL;
+}
+
+export {
+  credentialsPath,
+  readCredential,
+  writeCredential,
+  resolveControlUrl,
+  resolveControlUrlForUser
+};

package/dist/chunk-ZWCLCYCS.js

@@ -0,0 +1,146 @@
+// src/bundle.ts
+import { createHash } from "crypto";
+import { mkdir, writeFile } from "fs/promises";
+import * as path from "path";
+import { pathToFileURL } from "url";
+import { Worker } from "worker_threads";
+import * as esbuild from "esbuild";
+var ALLOWED_IMPORTS = ["@irtio/server", "@irtio/schema"];
+var BundleError = class extends Error {
+  name = "BundleError";
+};
+function importMenuPlugin(allowed) {
+  return {
+    name: "irtio-import-menu",
+    setup(build2) {
+      build2.onResolve({ filter: /^[^./]/ }, (args) => {
+        if (args.kind === "entry-point" || path.isAbsolute(args.path)) return null;
+        const root = args.path.split("/")[0].startsWith("@") ? args.path.split("/").slice(0, 2).join("/") : args.path.split("/")[0];
+        if (allowed.has(root)) {
+          const redirect = allowed.get(root);
+          if (redirect) return { path: redirect };
+          return null;
+        }
+        return {
+          errors: [
+            {
+              text: `irtio: room code may import only ${ALLOWED_IMPORTS.join(", ")} and local files (got ${JSON.stringify(args.path)})` + (args.path.startsWith("node:") || isNodeBuiltin(root) ? " \u2014 Node built-ins are not available in the room sandbox" : "")
+            }
+          ]
+        };
+      });
+    }
+  };
+}
+var NODE_BUILTINS = /* @__PURE__ */ new Set([
+  "assert",
+  "buffer",
+  "child_process",
+  "crypto",
+  "events",
+  "fs",
+  "http",
+  "https",
+  "net",
+  "os",
+  "path",
+  "process",
+  "stream",
+  "timers",
+  "tls",
+  "url",
+  "util",
+  "worker_threads",
+  "zlib"
+]);
+function isNodeBuiltin(name) {
+  return name.startsWith("node:") || NODE_BUILTINS.has(name);
+}
+async function bundleRoom(options) {
+  const allowed = new Map(
+    ALLOWED_IMPORTS.map((n) => [n, options.irtioPackages?.[n]])
+  );
+  let result;
+  try {
+    result = await esbuild.build({
+      entryPoints: [options.entry],
+      bundle: true,
+      format: "esm",
+      platform: "neutral",
+      target: "es2022",
+      write: false,
+      outdir: options.outDir,
+      plugins: [importMenuPlugin(allowed)],
+      logLevel: "silent",
+      mainFields: ["module", "main"],
+      conditions: ["import"]
+    });
+  } catch (err) {
+    const messages = err.errors?.map((e) => e.text).join("\n");
+    throw new BundleError(messages || String(err));
+  }
+  const out = result.outputFiles[0];
+  if (!out) throw new BundleError("esbuild produced no output");
+  const warnings = result.warnings.map((w) => w.text);
+  const hash = createHash("sha256").update(out.contents).digest("hex");
+  const file = path.join(options.outDir, `room.${hash.slice(0, 16)}.mjs`);
+  await mkdir(options.outDir, { recursive: true });
+  const banner = `// irtio room bundle ${hash}
+`;
+  await writeFile(file, banner + out.text);
+  if (options.verify === false) return { file, hash, warnings };
+  const verified = await verifyBundle(file);
+  const fullHash = createHash("sha256").update(out.contents).update(verified.canonical).digest("hex");
+  return {
+    file,
+    hash: fullHash,
+    schemaHash: verified.schemaHash,
+    mode: verified.mode,
+    warnings
+  };
+}
+async function verifyBundle(file) {
+  const probe = `
+    import { parentPort } from 'node:worker_threads';
+    try {
+      const mod = await import(${JSON.stringify(pathToFileURL(file).href)});
+      const def = mod.default;
+      const ok = def && def.kind === 'irtio-room' && def.version === 1;
+      if (!ok) {
+        parentPort.postMessage({ ok: false, reason:
+          'the bundle\\'s default export is not a room \u2014 end your room file with: export default defineRoom(schema, {...})' });
+      } else {
+        parentPort.postMessage({ ok: true, schemaHash: def.schema.hash, canonical: def.schema.canonical, mode: def.config.mode });
+      }
+    } catch (err) {
+      parentPort.postMessage({ ok: false, reason: String(err && err.stack || err) });
+    }
+  `;
+  const worker = new Worker(probe, { eval: true });
+  try {
+    const msg = await new Promise((resolve, reject) => {
+      const timer = setTimeout(
+        () => reject(new BundleError("bundle verification timed out")),
+        1e4
+      );
+      worker.once("message", (m) => {
+        clearTimeout(timer);
+        resolve(m);
+      });
+      worker.once("error", (e) => {
+        clearTimeout(timer);
+        reject(e);
+      });
+    });
+    if (!msg.ok) throw new BundleError(`bundle failed to load: ${msg.reason}`);
+    return { schemaHash: msg.schemaHash, canonical: msg.canonical, mode: msg.mode };
+  } finally {
+    await worker.terminate();
+  }
+}
+
+export {
+  ALLOWED_IMPORTS,
+  BundleError,
+  bundleRoom
+};

package/dist/deploy-4W6AYYEW.js

@@ -0,0 +1,308 @@
+import {
+  bundleRoom
+} from "./chunk-ZWCLCYCS.js";
+import {
+  ApiClientError,
+  createApiClient,
+  isLoginRequired
+} from "./chunk-J3G6AUJY.js";
+import {
+  resolveControlUrlForUser
+} from "./chunk-UYN5PWLT.js";
+
+// src/deploy.ts
+import { existsSync } from "fs";
+import { mkdtemp, readFile, readdir, rm } from "fs/promises";
+import { tmpdir } from "os";
+import * as path from "path";
+import { createInterface } from "readline/promises";
+import { pathToFileURL } from "url";
+import { diffSchemas, schemaFromCanonical } from "@irtio/schema";
+import pc from "picocolors";
+var ROOM_CANDIDATES = ["irtio/room.ts", "irtio/room.js", "room.ts"];
+var MIGRATIONS_DIR = "irtio/migrations";
+function parseDeployArgs(args) {
+  const parsed = {
+    allowBreaking: false
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--allow-breaking":
+        parsed.allowBreaking = true;
+        break;
+      case "--project": {
+        const value = args[++i];
+        if (value === void 0) throw new Error("irtio deploy: --project needs a value");
+        parsed.project = value;
+        break;
+      }
+      case "--url": {
+        const value = args[++i];
+        if (value === void 0) throw new Error("irtio deploy: --url needs a value");
+        parsed.url = value;
+        break;
+      }
+      case "--room": {
+        const value = args[++i];
+        if (value === void 0) throw new Error("irtio deploy: --room needs a value");
+        parsed.room = value;
+        break;
+      }
+      default:
+        throw new Error(`irtio deploy: unknown option ${JSON.stringify(arg)}`);
+    }
+  }
+  return parsed;
+}
+async function defaultAsk(question) {
+  if (!process.stdin.isTTY) return "";
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return await rl.question(question);
+  } finally {
+    rl.close();
+  }
+}
+function resolveEntry(cwd, room) {
+  if (room !== void 0) {
+    const file = path.resolve(cwd, room);
+    if (!existsSync(file)) throw new Error(`irtio deploy: 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 deploy: no room file found in ${cwd}
+  looked for: ${ROOM_CANDIDATES.join(", ")}
+  pass --room <file> if it lives elsewhere`
+  );
+}
+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 (err) {
+    throw new Error(`irtio deploy: ${file} is not valid JSON: ${String(err)}`);
+  }
+  const project = parsed?.project;
+  if (project === void 0) return void 0;
+  if (typeof project !== "string" || project.length === 0) {
+    throw new Error(`irtio deploy: ${file} has a "project" that is not a non-empty string`);
+  }
+  return project;
+}
+async function loadBundledSchema(file) {
+  const mod = await import(pathToFileURL(file).href);
+  return {
+    project: mod.default.schema.project,
+    canonical: mod.default.schema.canonical,
+    schema: mod.default.schema
+  };
+}
+function printBreaking(log, breaking, hint) {
+  const n = breaking.length;
+  log(pc.red(`deploy refused: ${n} breaking change${n === 1 ? "" : "s"}`));
+  for (const change of breaking) log(`  ${change.message}`);
+  log("");
+  log(pc.yellow(hint));
+}
+async function findMigrationFile(cwd, version) {
+  const dir = path.join(cwd, MIGRATIONS_DIR);
+  if (!existsSync(dir)) return void 0;
+  const entries = await readdir(dir);
+  const match = entries.find((f) => f.startsWith(`${version}_`) && f.endsWith(".ts"));
+  return match ? path.join(dir, match) : void 0;
+}
+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 entry = resolveEntry(cwd, options.room);
+  const outDir = await mkdtemp(path.join(tmpdir(), "irtio-deploy-"));
+  let result;
+  try {
+    result = await bundleRoom({
+      entry,
+      outDir,
+      ...options.irtioPackages !== void 0 ? { irtioPackages: options.irtioPackages } : {}
+    });
+  } catch (err) {
+    throw new Error(`irtio deploy: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  log(pc.green(`bundled ${path.basename(result.file)} (${result.hash.slice(0, 12)})`));
+  const bundled = await loadBundledSchema(result.file);
+  const client = options.client ?? await createApiClient(controlUrl);
+  const projectId = options.project ?? await readIrtioJsonProject(cwd) ?? bundled.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(...)'
+    );
+  }
+  let projectExists = true;
+  try {
+    await client.get(`/v1/projects/${projectId}`);
+  } catch (err) {
+    if (err instanceof ApiClientError && err.status === 404) projectExists = false;
+    else throw err;
+  }
+  if (!projectExists) {
+    const defaultName = path.basename(cwd);
+    const answer = (await ask(`project ${projectId} does not exist yet \u2014 name it [${defaultName}]: `)).trim();
+    const name = answer.length > 0 ? answer : defaultName;
+    await client.post("/v1/projects", { name, id: projectId });
+    log(pc.dim(`created project ${projectId} (${name})`));
+  }
+  const deployments = await client.get(
+    `/v1/projects/${projectId}/deployments`
+  );
+  const previous = deployments.reduce(
+    (best, d) => best === void 0 || d.version > best.version ? d : best,
+    void 0
+  );
+  let allowBreaking = options.allowBreaking ?? false;
+  let migrationFile;
+  const nextVersion = (previous?.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");
+    if (breaking.length > 0) {
+      if (!allowBreaking) {
+        printBreaking(log, breaking, "run: irtio migrate create <name>");
+        throw new DeployRefusedError();
+      }
+      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();
+      }
+      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 \u2014 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 bytes = new Uint8Array(await readFile(migrationBundle.file));
+    const uploaded = await client.postBytes(
+      `/v1/projects/${projectId}/artifacts`,
+      bytes
+    );
+    migrationKey = uploaded.key;
+    log(pc.green(`bundled and uploaded migration ${path.basename(migrationFile)}`));
+  }
+  const roomBytes = new Uint8Array(await readFile(result.file));
+  const uploadedRoom = await client.postBytes(
+    `/v1/projects/${projectId}/artifacts`,
+    roomBytes
+  );
+  log(pc.green("uploaded bundle"));
+  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 response;
+  try {
+    const created = await client.post(`/v1/projects/${projectId}/deployments`, {
+      bundleHash: result.hash,
+      bundleKey: uploadedRoom.key,
+      schemaJson: bundled.canonical,
+      schemaHash: result.schemaHash,
+      ...migrationKey !== void 0 ? { migrationKey } : {},
+      ...allowBreaking ? { allowBreaking: true } : {},
+      ...origin !== void 0 ? { origin } : {}
+    });
+    response = {
+      project: projectId,
+      version: created.version,
+      url: created.url,
+      draining: created.draining
+    };
+  } 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();
+    }
+    throw err;
+  }
+  await rm(outDir, { recursive: true, force: true }).catch(() => {
+  });
+  log(pc.green(`deployed v${response.version}`));
+  log(pc.dim(`reachable at ${response.url}`));
+  if (previous !== void 0) {
+    log(pc.dim(`rooms already running finish on v${previous.version}`));
+  }
+  return response;
+}
+var DeployRefusedError = class extends Error {
+  name = "DeployRefusedError";
+  constructor() {
+    super("deploy refused");
+  }
+};
+async function deploy(args, deps = {}) {
+  const log = deps.log ?? ((line) => console.log(line));
+  const errorLog = deps.errorLog ?? ((line) => console.error(line));
+  try {
+    const parsed = parseDeployArgs(args);
+    await runDeploy({
+      allowBreaking: parsed.allowBreaking,
+      log,
+      ...parsed.project !== void 0 ? { project: parsed.project } : {},
+      ...parsed.url !== void 0 ? { controlUrl: parsed.url } : {},
+      ...parsed.room !== void 0 ? { room: parsed.room } : {},
+      ...deps.client !== void 0 ? { client: deps.client } : {},
+      ...deps.cwd !== void 0 ? { cwd: deps.cwd } : {},
+      ...deps.irtioPackages !== void 0 ? { irtioPackages: deps.irtioPackages } : {}
+    });
+  } catch (err) {
+    if (err instanceof DeployRefusedError) {
+      process.exitCode = 1;
+      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 {
+  DeployRefusedError,
+  deploy,
+  parseDeployArgs,
+  runDeploy
+};