@cimplify/cli 0.15.3 → 0.17.0

package/dist/{chunk-3QUK5BPY.mjs → chunk-I7GEHLDD.mjs}

@@ -65,12 +65,14 @@ var CliError = class extends Error {
   code;
   exitCode;
   remediation;
+  details;
   constructor(code, message, options = {}) {
     super(message);
     this.name = "CliError";
     this.code = code;
     this.exitCode = options.exitCode ?? EXIT_CODE_FOR[code];
     this.remediation = options.remediation;
+    this.details = options.details;
   }
 };
 function isCliError(err) {
@@ -85,9 +87,12 @@ var RED_OPEN = "\x1B[31m";
 var GREEN_OPEN = "\x1B[32m";
 var YELLOW_OPEN = "\x1B[33m";
 var CYAN_OPEN = "\x1B[36m";
+var HONEY_OPEN = "\x1B[38;5;214m";
+var ORANGE_OPEN = "\x1B[38;5;208m";
 var PREFIX_STEP = "\u25B8";
 var PREFIX_SUCCESS = "\u2713";
 var PREFIX_FAILURE = "\u2717";
+var PREFIX_WARN = "!";
 var OUTPUT_MODE = {
   HUMAN: "human",
   JSON: "json"
@@ -138,6 +143,12 @@ function yellow(value) {
 function cyan(value) {
   return isJsonMode() ? value : wrap(CYAN_OPEN, value);
 }
+function honey(value) {
+  return isJsonMode() ? value : wrap(HONEY_OPEN, value);
+}
+function orange(value) {
+  return isJsonMode() ? value : wrap(ORANGE_OPEN, value);
+}
 function step(message) {
   if (isJsonMode()) return;
   console.log(`${cyan(PREFIX_STEP)} ${message}`);
@@ -150,6 +161,10 @@ function failure(message) {
   if (isJsonMode()) return;
   console.error(`${red(PREFIX_FAILURE)} ${message}`);
 }
+function warn(message) {
+  if (isJsonMode()) return;
+  console.error(`${orange(PREFIX_WARN)} ${message}`);
+}
 function info(message) {
   if (isJsonMode()) return;
   console.log(message);
@@ -163,4 +178,4 @@ function result(data) {
 `);
 }
 
-export { CLI_ERROR_CODE, CliError, EXIT_CODE, OUTPUT_MODE, bold, configureOutput, dim, failure, green, info, isAutoYes, isCliError, isInteractive, isJsonMode, red, result, step, success, yellow };
+export { CLI_ERROR_CODE, CliError, EXIT_CODE, OUTPUT_MODE, bold, configureOutput, dim, failure, green, honey, info, isAutoYes, isCliError, isInteractive, isJsonMode, orange, red, result, step, success, warn, yellow };

package/dist/chunk-ITDAICBY.mjs

@@ -0,0 +1,363 @@
+#!/usr/bin/env node
+import { LOCAL_ENVIRONMENT, resetLocalData, localEnvironments, localDataDir } from './chunk-NEB372WD.mjs';
+import { readInteractiveId, remoteCall, CHANNELS } from './chunk-JNCEKW2Y.mjs';
+import { requireInteractiveProject } from './chunk-BTNVYAC4.mjs';
+import { flagBool, flagString, parseArgs } from './chunk-XQAHREKO.mjs';
+import { ApiClient } from './chunk-XBQ4LO2N.mjs';
+import { readAuthOrNull } from './chunk-GGPN4QYQ.mjs';
+import { bold, dim, info, success, warn, result, CliError, CLI_ERROR_CODE } from './chunk-I7GEHLDD.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 };