@cimplify/cli 0.15.3 → 0.16.0

package/dist/{chunk-DMLQBAGC.mjs → chunk-EOO4UOQD.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { CliError, CLI_ERROR_CODE } from './chunk-3QUK5BPY.mjs';
+import { CliError, CLI_ERROR_CODE } from './chunk-KOD4GBQ5.mjs';
 import { randomBytes, createHash } from 'crypto';
 import { createServer } from 'http';
 import { spawn } from 'child_process';

package/dist/chunk-EYEMPIMP.mjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import { hasher, sha256, finish } from './chunk-25ZPFHLF.mjs';
+
+// src/interactives/build/chunk.ts
+var CHUNK_MAGIC = 1262701891;
+var CHUNK_FORMAT_VERSION = 1;
+var CHUNK_HEADER_BYTES = 64;
+var CHUNK_ALIGNMENT = 64;
+var CHUNK_KIND = {
+  code: 0,
+  texture: 1,
+  mesh: 2,
+  audio: 3,
+  font: 4,
+  data: 5,
+  wasm: 6,
+  index: 7,
+  bytecode: 8
+};
+var KIND_BY_CODE = ["code", "texture", "mesh", "audio", "font", "data", "wasm", "index", "bytecode"];
+var OFFSET_MAGIC = 0;
+var OFFSET_VERSION = 4;
+var OFFSET_KIND = 6;
+var OFFSET_FLAGS = 7;
+var OFFSET_LENGTH = 8;
+var OFFSET_PAYLOAD = 16;
+var OFFSET_ALIGNMENT = 20;
+var ZERO_PADDING = Buffer.alloc(CHUNK_ALIGNMENT);
+var CHUNK_PAYLOAD_PART = 1;
+function paddingFor(length) {
+  const rem = length % CHUNK_ALIGNMENT;
+  return rem === 0 ? 0 : CHUNK_ALIGNMENT - rem;
+}
+function encodeChunk(kind, payload) {
+  const header = Buffer.alloc(CHUNK_HEADER_BYTES);
+  header.writeUInt32LE(CHUNK_MAGIC, OFFSET_MAGIC);
+  header.writeUInt16LE(CHUNK_FORMAT_VERSION, OFFSET_VERSION);
+  header.writeUInt8(CHUNK_KIND[kind], OFFSET_KIND);
+  header.writeUInt8(0, OFFSET_FLAGS);
+  header.writeBigUInt64LE(BigInt(payload.length), OFFSET_LENGTH);
+  header.writeUInt32LE(CHUNK_HEADER_BYTES, OFFSET_PAYLOAD);
+  header.writeUInt32LE(CHUNK_ALIGNMENT, OFFSET_ALIGNMENT);
+  const pad = paddingFor(payload.length);
+  const padding = ZERO_PADDING.subarray(0, pad);
+  const hash = hasher();
+  hash.update(header);
+  hash.update(payload);
+  if (pad > 0) hash.update(padding);
+  return {
+    digest: finish(hash),
+    payloadDigest: kind === "wasm" ? sha256(payload) : null,
+    kind,
+    payloadBytes: payload.length,
+    totalBytes: CHUNK_HEADER_BYTES + payload.length + pad,
+    parts: pad > 0 ? [header, payload, padding] : [header, payload]
+  };
+}
+function decodeChunk(bytes) {
+  if (bytes.length < CHUNK_HEADER_BYTES) {
+    throw new Error("chunk is shorter than its header");
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, CHUNK_HEADER_BYTES);
+  if (view.getUint32(OFFSET_MAGIC, true) !== CHUNK_MAGIC) throw new Error("not a Cimplify chunk");
+  if (view.getUint16(OFFSET_VERSION, true) !== CHUNK_FORMAT_VERSION) throw new Error("unsupported chunk format version");
+  const code = view.getUint8(OFFSET_KIND);
+  const kind = KIND_BY_CODE[code];
+  if (kind === void 0) throw new Error(`unknown chunk kind ${code}`);
+  const length = view.getBigUint64(OFFSET_LENGTH, true);
+  const offset = view.getUint32(OFFSET_PAYLOAD, true);
+  if (length > BigInt(bytes.length - offset)) throw new Error("chunk payload is truncated");
+  return { kind, payload: bytes.subarray(offset, offset + Number(length)) };
+}
+
+export { CHUNK_ALIGNMENT, CHUNK_FORMAT_VERSION, CHUNK_HEADER_BYTES, CHUNK_KIND, CHUNK_PAYLOAD_PART, decodeChunk, encodeChunk };

package/dist/chunk-G2ZEFSQJ.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import { locateToolchain, localEngineRuntimeDir, validManifest, engineCacheRoot, cachedVersion, storeRuntime, cachedEngineRuntimeDir } from './chunk-ZUCDXRFI.mjs';
+import { ApiClient } from './chunk-CLQYPTJ2.mjs';
+import { readAuthOrNull } from './chunk-TT4YI33G.mjs';
+import { isCliError, CLI_ERROR_CODE, info, dim, warn } from './chunk-KOD4GBQ5.mjs';
+
+// src/interactives/build/engine-runtime-fetch.ts
+var ENGINE_RUNTIME_ROUTE = "/v1/interactives/engine/runtime";
+var ENGINE_RUNTIME_FILES_ROUTE = `${ENGINE_RUNTIME_ROUTE}/files`;
+var DOWNLOAD_TIMEOUT_MS = 5 * 60 * 1e3;
+async function signedInClient() {
+  const auth = await readAuthOrNull();
+  return auth === null ? null : ApiClient.fromAuth(auth);
+}
+async function ensureEngineRuntime(options) {
+  const sdkDir = locateToolchain(options.projectRoot)?.sdkDir ?? null;
+  const local = sdkDir === null ? null : localEngineRuntimeDir(sdkDir);
+  if (local !== null) return { source: "local", dir: local, version: null };
+  const client = options.client === void 0 ? await signedInClient() : options.client;
+  if (client === null) return { source: "signed_out", dir: null, version: null };
+  let manifest;
+  try {
+    manifest = await client.get(ENGINE_RUNTIME_ROUTE);
+  } catch (error) {
+    if (isCliError(error) && error.code === CLI_ERROR_CODE.NOT_FOUND) return { source: "unpublished", dir: null, version: null };
+    throw error;
+  }
+  if (!validManifest(manifest)) throw new Error("the registry returned an engine runtime manifest this CLI cannot use");
+  const root = options.root ?? engineCacheRoot();
+  const cached = cachedVersion(root, manifest.version);
+  if (cached !== null) return { source: "cached", dir: cached, version: manifest.version };
+  const download = (file) => client.getBytes(`${ENGINE_RUNTIME_FILES_ROUTE}/${file.sha256}`, { timeoutMs: DOWNLOAD_TIMEOUT_MS });
+  const dir = await storeRuntime(root, manifest, download);
+  return { source: "fetched", dir, version: manifest.version };
+}
+async function refreshEngineRuntime(projectRoot) {
+  try {
+    const fetched = await ensureEngineRuntime({ projectRoot });
+    if (fetched.source === "fetched") info(dim(`Downloaded the Cimplify Engine runtime ${fetched.version ?? ""}`));
+  } catch (error) {
+    if (cachedEngineRuntimeDir() !== null) return;
+    warn(`Could not update the Cimplify Engine runtime: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+export { ENGINE_RUNTIME_FILES_ROUTE, ENGINE_RUNTIME_ROUTE, ensureEngineRuntime, refreshEngineRuntime };

package/dist/{chunk-TH4XENKH.mjs → chunk-I4HNHPEM.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { isAutoYes, isInteractive, CliError, CLI_ERROR_CODE } from './chunk-3QUK5BPY.mjs';
+import { isAutoYes, isInteractive, CliError, CLI_ERROR_CODE } from './chunk-KOD4GBQ5.mjs';
 import readline from 'readline';
 
 async function promptLine(question) {

package/dist/chunk-JEVSFNPT.mjs

@@ -0,0 +1,363 @@
+#!/usr/bin/env node
+import { LOCAL_ENVIRONMENT, resetLocalData, localEnvironments, localDataDir } from './chunk-SF44L2OD.mjs';
+import { readInteractiveId, remoteCall, CHANNELS } from './chunk-SCKQ4XSD.mjs';
+import { requireInteractiveProject } from './chunk-CPBESPWK.mjs';
+import { flagBool, flagString, parseArgs } from './chunk-XQAHREKO.mjs';
+import { ApiClient } from './chunk-CLQYPTJ2.mjs';
+import { readAuthOrNull } from './chunk-TT4YI33G.mjs';
+import { bold, dim, info, success, warn, result, CliError, CLI_ERROR_CODE } from './chunk-KOD4GBQ5.mjs';
+
+// src/interactives/remote/environments.ts
+var BASE = "/v1/interactives";
+function segment(value) {
+  return encodeURIComponent(value);
+}
+function seedBody(seed) {
+  return { from: seed.from, at: seed.at, tables: [...seed.tables], kv_namespaces: [...seed.kvNamespaces] };
+}
+function change(body) {
+  return { change: body.change, table: body.table, column: body.column ?? null, index: body.index ?? null };
+}
+function environment(body) {
+  return {
+    name: body.name,
+    kind: body.kind,
+    status: body.status,
+    revision: body.revision_id,
+    previewToken: body.preview_token,
+    seed: body.seed === null ? null : { from: body.seed.from, at: body.seed.at, tables: body.seed.tables, kvNamespaces: body.seed.kv_namespaces },
+    schema: body.schema === null ? null : {
+      appliedVersion: body.schema.applied_version,
+      declaredVersion: body.schema.declared_version,
+      pending: body.schema.pending,
+      destructive: body.schema.destructive,
+      blocked: body.schema.blocked
+    },
+    createdAt: body.created_at,
+    lastActiveAt: body.last_active_at,
+    expiresAt: body.expires_at,
+    dataRollback: body.data_rollback
+  };
+}
+function diff(body) {
+  return {
+    environment: body.environment,
+    revision: body.revision_id,
+    fromVersion: body.from_version,
+    toVersion: body.to_version,
+    changes: body.changes.map(change),
+    destructive: body.destructive,
+    blocked: body.blocked,
+    reversible: body.reversible,
+    statements: body.statements
+  };
+}
+function migration(body) {
+  return {
+    id: body.id,
+    environment: body.environment,
+    revision: body.revision_id,
+    fromVersion: body.from_version,
+    toVersion: body.to_version,
+    changes: body.changes.map(change),
+    statements: body.statements,
+    reversible: body.reversible,
+    status: body.status,
+    appliedBy: body.applied_by,
+    appliedAt: body.applied_at,
+    rolledBackAt: body.rolled_back_at
+  };
+}
+var HttpEnvironments = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  path(interactiveId, rest = "") {
+    return `${BASE}/${segment(interactiveId)}/environments${rest}`;
+  }
+  async list(interactiveId) {
+    return (await this.client.get(this.path(interactiveId))).environments.map(environment);
+  }
+  async get(interactiveId, name) {
+    return environment(await this.client.get(this.path(interactiveId, `/${segment(name)}`)));
+  }
+  async create(interactiveId, request) {
+    return environment(
+      await this.client.post(this.path(interactiveId), {
+        name: request.name,
+        revision_id: request.revision,
+        seed: request.seed === null ? null : seedBody(request.seed)
+      })
+    );
+  }
+  async remove(interactiveId, name) {
+    await this.client.delete(this.path(interactiveId, `/${segment(name)}`));
+  }
+  async deploy(interactiveId, name, revision) {
+    return environment(await this.client.put(this.path(interactiveId, `/${segment(name)}/revision`), { revision_id: revision }));
+  }
+  async diff(interactiveId, name, to) {
+    const query = to === null ? "" : `?to=${to}`;
+    return diff(await this.client.get(this.path(interactiveId, `/${segment(name)}/diff${query}`)));
+  }
+  async migrate(interactiveId, name, confirmDestructive) {
+    const body = await this.client.post(this.path(interactiveId, `/${segment(name)}/migrate`), { confirm_destructive: confirmDestructive });
+    return body === null ? null : migration(body);
+  }
+  async promote(interactiveId, name, to, confirmDestructive) {
+    const body = await this.client.post(this.path(interactiveId, `/${segment(name)}/promote`), {
+      to,
+      confirm_destructive: confirmDestructive
+    });
+    return { revision: body.revision_id, to: body.to, migrations: body.migrations.map(migration) };
+  }
+  async seed(interactiveId, seed) {
+    return environment(await this.client.post(this.path(interactiveId, "/test/seed"), seedBody(seed)));
+  }
+  async rollback(interactiveId, name, to) {
+    const body = await this.client.post(
+      this.path(interactiveId, `/${segment(name)}/rollback`),
+      { to }
+    );
+    return { environment: body.environment, to: body.to, revision: body.revision_id, migrationsRolledBack: body.migrations_rolled_back };
+  }
+  async migrations(interactiveId, limit) {
+    return (await this.client.get(`${BASE}/${segment(interactiveId)}/migrations?limit=${limit}`)).map(migration);
+  }
+  async rollbackMigration(interactiveId, migrationId, confirm) {
+    return migration(await this.client.post(`${BASE}/${segment(interactiveId)}/migrations/${segment(migrationId)}/rollback`, { confirm }));
+  }
+};
+async function environmentsFromEnv() {
+  const auth = await readAuthOrNull();
+  if (auth === null) {
+    throw new CliError(CLI_ERROR_CODE.NOT_LOGGED_IN, "environments live on the Cimplify registry and need a signed-in account", {
+      remediation: "Run `cimplify login`. Local data for `cimplify dev` needs no account: `cimplify env list --local`."
+    });
+  }
+  return new HttpEnvironments(ApiClient.fromAuth(auth));
+}
+
+// src/interactives/commands/env.ts
+var USAGE = `usage:
+  cimplify env list [--local]
+  cimplify env create <name> [--revision <r>] [--seed-from live|test --seed-tables a,b --seed-kv a,b --seed-at <time>]
+  cimplify env delete <name>
+  cimplify env deploy <name> <revision>
+  cimplify env diff <name> [--to test|live]
+  cimplify env migrate <name> [--confirm]
+  cimplify env promote <name> --to test|live [--confirm]
+  cimplify env seed test --from live --tables a,b [--kv a,b] [--at <time>]
+  cimplify env rollback <name> --to <time>
+  cimplify env rollback --migration <id> [--confirm]
+  cimplify env migrations [--limit <n>]
+  cimplify env reset [<name>]`;
+var NAME_PATTERN = /^[a-z](?:[a-z0-9-]{0,38}[a-z0-9])?$/;
+var RESERVED = /* @__PURE__ */ new Set(["live", "test"]);
+var DEFAULT_MIGRATIONS = 20;
+function usage(detail) {
+  throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, detail === void 0 ? USAGE : `${detail}
+${USAGE}`);
+}
+function localEnvironmentName(raw) {
+  if (raw === void 0) return LOCAL_ENVIRONMENT;
+  if (raw !== LOCAL_ENVIRONMENT && !NAME_PATTERN.test(raw)) usage(`'${raw}' is not an environment name: lowercase letters, digits and dashes, starting with a letter`);
+  return raw;
+}
+function environmentName(raw, allowChannels) {
+  if (raw === void 0) usage();
+  if (RESERVED.has(raw)) {
+    if (allowChannels) return raw;
+    usage(`'${raw}' is a channel; branch environments take another name`);
+  }
+  if (!NAME_PATTERN.test(raw) || raw === LOCAL_ENVIRONMENT) usage(`'${raw}' is not an environment name: lowercase letters, digits and dashes, starting with a letter`);
+  return raw;
+}
+function channel(raw, flag) {
+  if (raw === void 0 || !CHANNELS.includes(raw)) usage(`--${flag} must be live or test`);
+  return raw;
+}
+function list(raw) {
+  if (raw === void 0) return [];
+  return raw.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+}
+function time(raw, flag) {
+  if (raw === void 0) usage(`--${flag} needs a time, for example 2026-10-14T09:30:00Z`);
+  const parsed = new Date(raw);
+  if (Number.isNaN(parsed.getTime())) usage(`--${flag} is not a time: '${raw}'`);
+  return parsed.toISOString();
+}
+function seedFrom(args, prefix) {
+  const from = flagString(args, `${prefix}from`);
+  if (from === void 0) return null;
+  const at = flagString(args, `${prefix}at`);
+  return {
+    from: channel(from, `${prefix}from`),
+    at: at === void 0 ? null : time(at, `${prefix}at`),
+    tables: list(flagString(args, `${prefix}tables`)),
+    kvNamespaces: list(flagString(args, `${prefix}kv`))
+  };
+}
+function parseEnvCommand(args) {
+  const [action, first, second] = args.positional;
+  const confirm = flagBool(args, "confirm") || flagBool(args, "yes");
+  switch (action) {
+    case "list":
+    case "ls":
+      return { action: "list", local: flagBool(args, "local") };
+    case "create":
+      return { action: "create", name: environmentName(first, false), revision: flagString(args, "revision") ?? null, seed: seedFrom(args, "seed-") };
+    case "delete":
+    case "rm":
+      return { action: "delete", name: environmentName(first, false) };
+    case "deploy":
+      if (second === void 0) usage();
+      return { action: "deploy", name: environmentName(first, false), revision: second };
+    case "diff": {
+      const to = flagString(args, "to");
+      return { action: "diff", name: environmentName(first, true), to: to === void 0 ? null : channel(to, "to") };
+    }
+    case "migrate":
+      return { action: "migrate", name: environmentName(first, true), confirm };
+    case "promote":
+      return { action: "promote", name: environmentName(first, true), to: channel(flagString(args, "to"), "to"), confirm };
+    case "seed": {
+      if (first !== "test") usage("only test is seeded; a branch takes --seed-from when it is created");
+      const seed = seedFrom(args, "");
+      if (seed === null) usage("seed needs --from live");
+      return { action: "seed", seed };
+    }
+    case "rollback": {
+      const migration2 = flagString(args, "migration");
+      if (migration2 !== void 0) return { action: "undo", migration: migration2, confirm };
+      return { action: "rollback", name: environmentName(first, true), to: time(flagString(args, "to"), "to") };
+    }
+    case "migrations": {
+      const limit = Number(flagString(args, "limit") ?? DEFAULT_MIGRATIONS);
+      if (!Number.isInteger(limit) || limit < 1 || limit > 100) usage("--limit is 1 to 100");
+      return { action: "migrations", limit };
+    }
+    case "reset":
+      return { action: "reset", name: first === void 0 ? null : localEnvironmentName(first) };
+    default:
+      return usage();
+  }
+}
+async function runEnvCommand(root, remote, command) {
+  if (command.action === "reset") return { kind: "reset", removed: await resetLocalData(root, command.name) };
+  if (command.action === "list" && command.local) {
+    return { kind: "local", environments: localEnvironments(root).map((name) => ({ name, dir: localDataDir(root, name) })) };
+  }
+  const id = await readInteractiveId(root);
+  const environments = await remote();
+  switch (command.action) {
+    case "list":
+      return { kind: "environments", environments: await remoteCall(() => environments.list(id)) };
+    case "create":
+      return { kind: "environment", environment: await remoteCall(() => environments.create(id, command)) };
+    case "delete":
+      await remoteCall(() => environments.remove(id, command.name));
+      return { kind: "deleted", name: command.name };
+    case "deploy":
+      return { kind: "environment", environment: await remoteCall(() => environments.deploy(id, command.name, command.revision)) };
+    case "diff":
+      return { kind: "diff", diff: await remoteCall(() => environments.diff(id, command.name, command.to)) };
+    case "migrate": {
+      const planned = await remoteCall(() => environments.diff(id, command.name, null));
+      if (planned.destructive && !command.confirm) return { kind: "diff", diff: planned };
+      return { kind: "migration", migration: await remoteCall(() => environments.migrate(id, command.name, command.confirm)) };
+    }
+    case "promote": {
+      const planned = await remoteCall(() => environments.diff(id, command.name, command.to));
+      if (planned.destructive && !command.confirm) return { kind: "diff", diff: planned };
+      const promoted = await remoteCall(() => environments.promote(id, command.name, command.to, command.confirm));
+      return { kind: "promoted", revision: promoted.revision, to: promoted.to, migrations: promoted.migrations };
+    }
+    case "seed":
+      return { kind: "environment", environment: await remoteCall(() => environments.seed(id, command.seed)) };
+    case "rollback": {
+      const rolled = await remoteCall(() => environments.rollback(id, command.name, command.to));
+      return { kind: "rolled_back", environment: rolled.environment, to: rolled.to, revision: rolled.revision, migrations: rolled.migrationsRolledBack };
+    }
+    case "undo":
+      return { kind: "migration", migration: await remoteCall(() => environments.rollbackMigration(id, command.migration, command.confirm)) };
+    case "migrations":
+      return { kind: "migrations", migrations: await remoteCall(() => environments.migrations(id, command.limit)) };
+  }
+}
+function renderDiff(diff2) {
+  const lines = [`${bold(diff2.environment)} schema v${diff2.fromVersion} -> v${diff2.toVersion}${diff2.revision === null ? "" : dim(` (${diff2.revision})`)}`];
+  if (diff2.changes.length === 0) lines.push(dim("  no schema changes"));
+  for (const c of diff2.changes) {
+    const target = [c.table, c.column ?? c.index].filter((part) => part !== null).join(".");
+    const mark = c.change.startsWith("drop") || c.change === "retype_column" ? "-" : c.change === "rekey_table" || c.change === "add_required_column" ? "!" : "+";
+    lines.push(`  ${mark} ${c.change.replaceAll("_", " ")} ${target}`);
+  }
+  for (const s of diff2.statements) lines.push(dim(`    ${s}`));
+  if (diff2.blocked) lines.push("  blocked: a table changes its key or gains a required column; declare a new table or a nullable column");
+  else if (diff2.destructive) lines.push("  destructive: drops data; rerun with --confirm to apply");
+  else if (diff2.changes.length > 0) lines.push(dim(diff2.reversible ? "  additive: can be rolled back with env rollback --migration" : "  cannot be rolled back"));
+  return lines;
+}
+function renderEnvironment(e) {
+  const schema = e.schema === null ? dim("schema unknown") : `schema v${e.schema.appliedVersion}${e.schema.pending ? ` (v${e.schema.declaredVersion} pending${e.schema.destructive ? ", destructive" : ""})` : ""}`;
+  const preview = e.previewToken === null ? "" : `  preview ${e.previewToken}`;
+  const seed = e.seed === null ? "" : dim(`  seeded from ${e.seed.from} at ${e.seed.at}`);
+  const expiry = e.expiresAt === null ? "" : dim(`  idle expiry ${e.expiresAt}`);
+  return `${bold(e.name.padEnd(16))} ${e.kind.padEnd(6)} ${e.revision ?? dim("no revision")}  ${schema}${preview}${seed}${expiry}`;
+}
+function renderMigration(m) {
+  return `${m.id} ${m.environment} v${m.fromVersion} -> v${m.toVersion} ${m.status}${m.reversible ? "" : dim(" (not reversible)")} ${dim(m.appliedAt)}`;
+}
+function renderEnvOutcome(outcome) {
+  switch (outcome.kind) {
+    case "environments":
+      for (const e of outcome.environments) info(renderEnvironment(e));
+      return;
+    case "local":
+      if (outcome.environments.length === 0) info(dim("no local data yet; cimplify dev creates it on first use"));
+      for (const e of outcome.environments) info(`${bold(e.name.padEnd(16))} ${dim(e.dir)}`);
+      return;
+    case "environment":
+      success(renderEnvironment(outcome.environment));
+      return;
+    case "deleted":
+      success(`${outcome.name} deleted with its data and preview link`);
+      return;
+    case "diff":
+      for (const line of renderDiff(outcome.diff)) info(line);
+      if (outcome.diff.destructive && !outcome.diff.blocked) warn("nothing was applied");
+      return;
+    case "migration":
+      if (outcome.migration === null) success("data already holds the declared schema");
+      else success(renderMigration(outcome.migration));
+      return;
+    case "migrations":
+      if (outcome.migrations.length === 0) info(dim("no migrations recorded"));
+      for (const m of outcome.migrations) info(renderMigration(m));
+      return;
+    case "promoted":
+      success(`${outcome.revision} is on ${outcome.to}`);
+      for (const m of outcome.migrations) info(`  ${renderMigration(m)}`);
+      return;
+    case "rolled_back":
+      success(`${outcome.environment} code and data are back at ${outcome.to}${outcome.revision === null ? "" : ` on ${outcome.revision}`}`);
+      if (outcome.migrations.length > 0) info(dim(`  migrations rolled back: ${outcome.migrations.join(", ")}`));
+      return;
+    case "reset":
+      if (outcome.removed.length === 0) info(dim("no local data to reset"));
+      for (const name of outcome.removed) success(`local ${name} data reset`);
+      return;
+  }
+}
+async function run(argv) {
+  const command = parseEnvCommand(parseArgs(argv));
+  const root = process.cwd();
+  requireInteractiveProject(root, "env");
+  const outcome = await runEnvCommand(root, environmentsFromEnv, command);
+  renderEnvOutcome(outcome);
+  result(outcome);
+}
+
+export { localEnvironmentName, parseEnvCommand, renderDiff, renderEnvOutcome, run, runEnvCommand };