zinkee 0.1.44 → 0.1.46

package/src/commands/automations.ts

@@ -1,2102 +0,0 @@
-import { readFileSync } from "node:fs";
-import type { Writable } from "node:stream";
-
-import { Command, InvalidArgumentError } from "commander";
-
-import {
-  AutomationsApi,
-  type ApiAutomation,
-  type ApiAutomationAction,
-  type ApiAutomationConnection,
-  type ApiAutomationFolder,
-  type ApiAutomationPlugin,
-  type CreateAutomationConnectionInput,
-  type CreateAutomationInput,
-  type MutationAutomationActionInput,
-  type SetAutomationFlowInput,
-  type SetAutomationTriggerInput,
-  type SetAutomationWebhookInput,
-  type UpdateAutomationConnectionInput,
-  type UpdateAutomationInput,
-} from "../api/automations.js";
-import { ApiClient } from "../client.js";
-import { defaultConfigPath, readRuntimeConfig } from "../config.js";
-import { parseJsonAssignment, parseKeyValue } from "../parsers/kv.js";
-import {
-  normalizeUuidOrSlug,
-  type NormalizedUuidOrSlug,
-} from "../parsers/selectors.js";
-import { resolveRuntimeContext } from "../runtime-context.js";
-import type { JsonObject, JsonValue, RuntimeOverrides } from "../types.js";
-import { CliError } from "../utils/errors.js";
-import { buildJsonSuccess, folderColumns, FOLDER_TABLE_KEYS, printTable } from "../utils/output.js";
-
-interface CommandIo {
-  write(chunk: string): unknown;
-}
-
-export interface RegisterAutomationsCommandsOptions {
-  configPath?: string;
-  stdout?: CommandIo;
-}
-
-interface GlobalOptions extends RuntimeOverrides {}
-
-interface FolderMutationCommandOptions {
-  name?: string;
-}
-
-interface FolderMoveCommandOptions {
-  to?: NormalizedUuidOrSlug;
-}
-
-interface AutomationListCommandOptions {
-  folder?: NormalizedUuidOrSlug;
-  status?: string;
-  triggerType?: string;
-  actionType?: string;
-  plugin?: string;
-  search?: string;
-}
-
-interface TriggerPayloadCommandOptions {
-  triggerType?: string;
-  cron?: string;
-  triggerSchema?: string;
-  triggerField?: string[];
-  condition?: string[];
-  conditionJson?: string[];
-  webhookEndpointId?: string;
-  raw?: string;
-  rawFile?: string;
-}
-
-interface AutomationCreateCommandOptions extends TriggerPayloadCommandOptions {
-  name?: string;
-  description?: string;
-  folder?: NormalizedUuidOrSlug;
-}
-
-interface AutomationUpdateCommandOptions {
-  name?: string;
-  description?: string;
-  folder?: NormalizedUuidOrSlug;
-  raw?: string;
-  rawFile?: string;
-}
-
-interface ActionMutationCommandOptions {
-  type?: string;
-  name?: string;
-  targetSchema?: string;
-  map?: string[];
-  mapJson?: string[];
-  condition?: string[];
-  conditionJson?: string[];
-  useTriggerRecord?: boolean;
-  method?: string;
-  url?: string;
-  header?: string[];
-  body?: string;
-  bodyFile?: string;
-  contentType?: string;
-  timeoutMs?: number;
-  var?: string[];
-  authMode?: string;
-  connection?: string;
-  plugin?: string;
-  arg?: string[];
-  argJson?: string[];
-  to?: string;
-  subject?: string;
-  message?: string;
-  documentTemplate?: string;
-  targetFileField?: string;
-  raw?: string;
-  rawFile?: string;
-}
-
-interface FlowSetCommandOptions {
-  entry?: string[];
-  transition?: string[];
-  raw?: string;
-  rawFile?: string;
-}
-
-interface WebhookSetCommandOptions {
-  active?: boolean;
-  idempotencyKeyPath?: string;
-  eventTypePath?: string;
-  allowedEventType?: string[];
-  fieldMapping?: string[];
-  fieldMappingFile?: string[];
-  raw?: string;
-  rawFile?: string;
-}
-
-interface ConnectionCreateCommandOptions {
-  name?: string;
-  type?: string;
-  scope?: string;
-  ownerMember?: string;
-  config?: string;
-  configFile?: string;
-  secret?: string[];
-  active?: boolean;
-  raw?: string;
-  rawFile?: string;
-}
-
-interface ConnectionUpdateCommandOptions {
-  set?: string[];
-  unset?: string[];
-  raw?: string;
-  rawFile?: string;
-}
-
-type ConditionSpec = JsonObject & {
-  field: string;
-  comparator: string;
-  values: JsonValue[];
-};
-
-type TransitionSpec = JsonObject & {
-  fromActionId: string;
-  toActionId: string;
-};
-
-function getCommandIo(stdout: CommandIo | undefined): CommandIo {
-  return stdout ?? (process.stdout as Writable);
-}
-
-function writeLine(stdout: CommandIo, value: string): void {
-  stdout.write(`${value}\n`);
-}
-
-function getGlobalOptions(command: Command): GlobalOptions {
-  return command.optsWithGlobals<GlobalOptions>();
-}
-
-function emitJson(
-  stdout: CommandIo,
-  commandName: string,
-  data: unknown,
-  configPath: string,
-): void {
-  writeLine(
-    stdout,
-    JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath })),
-  );
-}
-
-function toConfigurationError(filePath: string, error: unknown): never {
-  if (error instanceof CliError) {
-    throw error;
-  }
-
-  if (
-    typeof error === "object" &&
-    error !== null &&
-    "code" in error &&
-    error.code === "ENOENT"
-  ) {
-    throw new CliError("configuration_error", `Config file not found at ${filePath}.`);
-  }
-
-  if (error instanceof Error) {
-    throw new CliError("configuration_error", error.message);
-  }
-
-  throw error;
-}
-
-function createAutomationsApi(
-  command: Command,
-  filePath: string,
-): { api: AutomationsApi; json: boolean; readOnly: boolean } {
-  try {
-    const config = readRuntimeConfig(filePath);
-    const runtime = resolveRuntimeContext(config, getGlobalOptions(command));
-
-    if (!runtime.baseUrl) {
-      throw new CliError(
-        "configuration_error",
-        `Resolved profile "${runtime.profile}" is missing a base URL.`,
-      );
-    }
-
-    return {
-      api: new AutomationsApi(
-        new ApiClient({
-          baseUrl: runtime.baseUrl,
-          apiKey: runtime.apiKey,
-        }),
-      ),
-      json: runtime.json,
-      readOnly: runtime.readOnly,
-    };
-  } catch (error) {
-    toConfigurationError(filePath, error);
-  }
-}
-
-function ensureWritable(
-  commandName: string,
-  readOnly: boolean,
-  commandMode: "write" | "destructive",
-): void {
-  if (readOnly) {
-    throw new CliError(
-      "command_not_allowed_in_read_only_mode",
-      `Command "${commandName}" is not allowed in read-only mode.`,
-      {
-        commandMode,
-        executionMode: "read-only",
-      },
-    );
-  }
-}
-
-function parseUuidOrSlugSelector(input: string): NormalizedUuidOrSlug {
-  try {
-    return normalizeUuidOrSlug(input);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Invalid selector.";
-    throw new InvalidArgumentError(message);
-  }
-}
-
-function collectValues(value: string, previous: string[] = []): string[] {
-  return [...previous, value];
-}
-
-function parseNonNegativeInteger(input: string): number {
-  if (!/^\d+$/.test(input.trim())) {
-    throw new InvalidArgumentError(`Expected a non-negative integer, received "${input}".`);
-  }
-
-  return Number(input);
-}
-
-function isJsonObject(value: unknown): value is JsonObject {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function isEmptyObject(value: object): boolean {
-  return Object.keys(value).length === 0;
-}
-
-function readRawSetPayload(raw: JsonObject, label: string): JsonObject {
-  const setValue = raw.set;
-
-  if (setValue === undefined) {
-    return {};
-  }
-
-  if (!isJsonObject(setValue)) {
-    throw new CliError(
-      "invalid_cli_usage",
-      `Expected ${label} field "set" to be a JSON object.`,
-    );
-  }
-
-  return { ...setValue };
-}
-
-function readRawUnsetPayload(raw: JsonObject, label: string): string[] {
-  const unsetValue = raw.unset;
-
-  if (unsetValue === undefined) {
-    return [];
-  }
-
-  if (!Array.isArray(unsetValue) || !unsetValue.every((value) => typeof value === "string")) {
-    throw new CliError(
-      "invalid_cli_usage",
-      `Expected ${label} field "unset" to be an array of strings.`,
-    );
-  }
-
-  return [...unsetValue];
-}
-
-function splitRawPatchPayload(
-  raw: JsonObject,
-  label: string,
-): { set: JsonObject; unset: string[] } {
-  const set: JsonObject = { ...raw };
-  delete set.set;
-  delete set.unset;
-
-  return {
-    set: {
-      ...set,
-      ...readRawSetPayload(raw, label),
-    },
-    unset: readRawUnsetPayload(raw, label),
-  };
-}
-
-function setNestedPath(target: JsonObject, path: readonly string[], value: JsonValue): void {
-  const [head, ...tail] = path;
-
-  if (!head) {
-    return;
-  }
-
-  if (tail.length === 0) {
-    target[head] = value;
-    return;
-  }
-
-  const next = isJsonObject(target[head]) ? { ...target[head] } : {};
-  target[head] = next;
-  setNestedPath(next, tail, value);
-}
-
-function hasSetPath(target: JsonObject, path: string): boolean {
-  if (Object.hasOwn(target, path)) {
-    return true;
-  }
-
-  const segments = path.split(".").filter(Boolean);
-
-  if (segments.length <= 1) {
-    return Object.hasOwn(target, path);
-  }
-
-  let current: unknown = target;
-
-  for (const segment of segments) {
-    if (!isJsonObject(current) || !Object.hasOwn(current, segment)) {
-      return false;
-    }
-
-    current = current[segment];
-  }
-
-  return true;
-}
-
-function parseJsonValue(input: string, sourceLabel: string): JsonValue {
-  try {
-    return JSON.parse(input) as JsonValue;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Invalid JSON.";
-    throw new CliError(
-      "invalid_cli_usage",
-      `Failed to parse JSON from ${sourceLabel}: ${message}`,
-    );
-  }
-}
-
-function parseJsonObject(input: string, sourceLabel: string): JsonObject {
-  const parsed = parseJsonValue(input, sourceLabel);
-
-  if (!isJsonObject(parsed)) {
-    throw new CliError(
-      "invalid_cli_usage",
-      `Expected ${sourceLabel} to contain a JSON object.`,
-    );
-  }
-
-  return parsed;
-}
-
-function readTextFile(filePath: string, label: string): string {
-  try {
-    return readFileSync(filePath, "utf8");
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unable to read file.";
-    throw new CliError(
-      "invalid_cli_usage",
-      `Failed to read ${label} from ${filePath}: ${message}`,
-    );
-  }
-}
-
-function readJsonValueOption(
-  raw: string | undefined,
-  rawFile: string | undefined,
-  rawLabel: string,
-  rawFileLabel: string,
-): JsonValue | undefined {
-  if (raw && rawFile) {
-    throw new CliError(
-      "invalid_cli_usage",
-      `Provide either "${rawLabel}" or "${rawFileLabel}", not both.`,
-    );
-  }
-
-  if (raw) {
-    return parseJsonValue(raw, rawLabel);
-  }
-
-  if (rawFile) {
-    return parseJsonValue(readTextFile(rawFile, rawFileLabel), `${rawFileLabel} ${rawFile}`);
-  }
-
-  return undefined;
-}
-
-function readJsonObjectOption(
-  raw: string | undefined,
-  rawFile: string | undefined,
-  rawLabel: string,
-  rawFileLabel: string,
-): JsonObject {
-  return (
-    readJsonValueOption(raw, rawFile, rawLabel, rawFileLabel) ?? {}
-  ) as JsonObject;
-}
-
-const NO_VALUE_COMPARATORS = new Set([
-  "chg",
-  "changes",
-  "ie",
-  "is_empty",
-  "ine",
-  "is_not_empty",
-]);
-
-function isNoValueComparator(comparator: string): boolean {
-  return NO_VALUE_COMPARATORS.has(comparator.toLowerCase());
-}
-
-function conditionFormatError(input: string): CliError {
-  return new CliError(
-    "invalid_cli_usage",
-    `Expected condition in the form field:comparator:value, or field:comparator for comparators without value (chg, ie, ine), received "${input}".`,
-  );
-}
-
-function parseCondition(input: string): ConditionSpec {
-  const firstSeparator = input.indexOf(":");
-  const secondSeparator = input.indexOf(":", firstSeparator + 1);
-
-  if (firstSeparator <= 0) {
-    throw conditionFormatError(input);
-  }
-
-  if (secondSeparator === -1) {
-    const field = input.slice(0, firstSeparator).trim();
-    const comparator = input.slice(firstSeparator + 1).trim();
-
-    if (!field || !comparator || !isNoValueComparator(comparator)) {
-      throw conditionFormatError(input);
-    }
-
-    return { field, comparator, values: [] };
-  }
-
-  if (secondSeparator <= firstSeparator + 1) {
-    throw conditionFormatError(input);
-  }
-
-  const field = input.slice(0, firstSeparator).trim();
-  const comparator = input.slice(firstSeparator + 1, secondSeparator).trim();
-  const value = input.slice(secondSeparator + 1).trim();
-
-  if (!field || !comparator || !value) {
-    throw conditionFormatError(input);
-  }
-
-  return {
-    field,
-    comparator,
-    values: value
-      .split(",")
-      .map((entry) => entry.trim())
-      .filter(Boolean),
-  };
-}
-
-function parseJsonCondition(input: string, label: string): ConditionSpec {
-  const parsed = parseJsonObject(input, label);
-  const field = typeof parsed.field === "string" ? parsed.field.trim() : "";
-  const comparator = typeof parsed.comparator === "string" ? parsed.comparator.trim() : "";
-  const values = parsed.values;
-
-  if (!field || !comparator || !Array.isArray(values)) {
-    throw new CliError(
-      "invalid_cli_usage",
-      `Expected ${label} to contain {"field","comparator","values"}.`,
-    );
-  }
-
-  return {
-    ...parsed,
-    field,
-    comparator,
-    values: [...values],
-  };
-}
-
-function parseTransition(input: string): TransitionSpec {
-  const separatorIndex = input.indexOf(":");
-
-  if (separatorIndex <= 0 || separatorIndex === input.length - 1) {
-    throw new CliError(
-      "invalid_cli_usage",
-      `Expected transition in the form from:to, received "${input}".`,
-    );
-  }
-
-  const fromActionId = input.slice(0, separatorIndex).trim();
-  const toActionId = input.slice(separatorIndex + 1).trim();
-
-  if (!fromActionId || !toActionId) {
-    throw new CliError(
-      "invalid_cli_usage",
-      `Expected transition in the form from:to, received "${input}".`,
-    );
-  }
-
-  return { fromActionId, toActionId };
-}
-
-function parseStringAssignments(values: readonly string[] | undefined): Record<string, string> {
-  const result: Record<string, string> = {};
-
-  for (const value of values ?? []) {
-    const assignment = parseKeyValue(value);
-    result[assignment.key] = assignment.value;
-  }
-
-  return result;
-}
-
-function parseJsonAssignments(values: readonly string[] | undefined): JsonObject {
-  const result: JsonObject = {};
-
-  for (const value of values ?? []) {
-    const assignment = parseJsonAssignment<JsonValue>(value);
-    result[assignment.key] = assignment.value;
-  }
-
-  return result;
-}
-
-function mergeMappings(
-  stringAssignments: readonly string[] | undefined,
-  jsonAssignments: readonly string[] | undefined,
-): JsonObject {
-  return {
-    ...parseStringAssignments(stringAssignments),
-    ...parseJsonAssignments(jsonAssignments),
-  };
-}
-
-const AUTOMATION_SOURCE_TYPES = new Set(["TRIGGER", "PREVIOUS_ACTION"]);
-
-type AutomationSourceType = "TRIGGER" | "PREVIOUS_ACTION";
-
-type AutomationValueSource = JsonObject & {
-  type: AutomationSourceType;
-  id: string;
-};
-
-type AutomationResolvedValue = JsonObject & {
-  rawValue: JsonValue | null;
-  source: AutomationValueSource | null;
-};
-
-function isAutomationValueSource(value: unknown): value is AutomationValueSource {
-  return (
-    isJsonObject(value) &&
-    typeof value.type === "string" &&
-    AUTOMATION_SOURCE_TYPES.has(value.type) &&
-    typeof value.id === "string" &&
-    value.id.trim().length > 0
-  );
-}
-
-function looksLikeAutomationResolvedValue(value: unknown): value is JsonObject {
-  if (!isJsonObject(value)) {
-    return false;
-  }
-
-  if ("rawValue" in value) {
-    return true;
-  }
-
-  if (!Object.hasOwn(value, "source")) {
-    return false;
-  }
-
-  return value.source === null || isAutomationValueSource(value.source);
-}
-
-function normalizeAutomationResolvedValue(
-  value: JsonValue,
-  label: string,
-  options: { allowSource: boolean },
-): AutomationResolvedValue {
-  if (!looksLikeAutomationResolvedValue(value)) {
-    return {
-      rawValue: value,
-      source: null,
-    };
-  }
-
-  const rawValue = Object.hasOwn(value, "rawValue") ? (value.rawValue as JsonValue | null) : undefined;
-  const sourceValue = Object.hasOwn(value, "source") ? value.source : undefined;
-  const hasRawValue = rawValue !== undefined && rawValue !== null;
-  const hasSource = sourceValue !== undefined && sourceValue !== null;
-
-  if (hasRawValue === hasSource) {
-    throw new CliError(
-      "invalid_cli_usage",
-      `Expected ${label} to define exactly one of "rawValue" or "source".`,
-    );
-  }
-
-  if (hasSource) {
-    if (!options.allowSource) {
-      throw new CliError(
-        "invalid_cli_usage",
-        `Expected ${label} to use only literal "rawValue" values.`,
-      );
-    }
-
-    if (!isAutomationValueSource(sourceValue)) {
-      throw new CliError(
-        "invalid_cli_usage",
-        `Expected ${label} "source" to contain a valid automation source reference.`,
-      );
-    }
-
-    return {
-      rawValue: null,
-      source: {
-        type: sourceValue.type,
-        id: sourceValue.id,
-      },
-    };
-  }
-
-  return {
-    rawValue: rawValue ?? null,
-    source: null,
-  };
-}
-
-function normalizeAutomationFieldMapping(mapping: JsonObject, label: string): JsonObject {
-  const normalized: JsonObject = {};
-
-  for (const [field, value] of Object.entries(mapping)) {
-    normalized[field] = normalizeAutomationResolvedValue(
-      value as JsonValue,
-      `${label} "${field}"`,
-      { allowSource: true },
-    );
-  }
-
-  return normalized;
-}
-
-function normalizeAutomationConditions(
-  conditions: readonly unknown[],
-  label: string,
-  options: { allowSource: boolean },
-): ConditionSpec[] {
-  return conditions.map((condition, index) => {
-    if (!isJsonObject(condition)) {
-      throw new CliError(
-        "invalid_cli_usage",
-        `Expected ${label} ${index + 1} to be a JSON object.`,
-      );
-    }
-
-    const field = typeof condition.field === "string" ? condition.field.trim() : "";
-    const comparator = typeof condition.comparator === "string" ? condition.comparator.trim() : "";
-    const values = condition.values;
-
-    const allowsEmptyValues = isNoValueComparator(comparator);
-    if (!field || !comparator || !Array.isArray(values) || (values.length === 0 && !allowsEmptyValues)) {
-      throw new CliError(
-        "invalid_cli_usage",
-        `Expected ${label} ${index + 1} to contain "field", "comparator", and a non-empty "values" array (comparators without value, e.g. chg/ie/ine, accept an empty array).`,
-      );
-    }
-
-    return {
-      ...condition,
-      field,
-      comparator,
-      values: values.map((value, valueIndex) =>
-        normalizeAutomationResolvedValue(
-          value as JsonValue,
-          `${label} ${index + 1} value ${valueIndex + 1}`,
-          options,
-        ),
-      ),
-    };
-  });
-}
-
-function readConditions(
-  literalConditions: readonly string[] | undefined,
-  jsonConditions: readonly string[] | undefined,
-  label: string,
-): ConditionSpec[] {
-  return [
-    ...(literalConditions ?? []).map(parseCondition),
-    ...(jsonConditions ?? []).map((value, index) =>
-      parseJsonCondition(value, `${label} ${index + 1}`),
-    ),
-  ];
-}
-
-function resolveFolder(
-  folders: readonly ApiAutomationFolder[],
-  selector: NormalizedUuidOrSlug,
-): ApiAutomationFolder {
-  if (selector.kind === "uuid") {
-    const match = folders.find((folder) => folder.id === selector.value);
-
-    if (match) {
-      return match;
-    }
-  }
-
-  const matches = folders.filter((folder) => folder.name === selector.value);
-
-  if (matches.length === 1) {
-    return matches[0] as ApiAutomationFolder;
-  }
-
-  if (matches.length > 1) {
-    throw new CliError(
-      "invalid_cli_usage",
-      `Folder "${selector.value}" is ambiguous. Found ${matches.length} matches.`,
-    );
-  }
-
-  throw new CliError("invalid_cli_usage", `Folder "${selector.value}" was not found.`);
-}
-
-async function resolveFolderSelector(
-  api: AutomationsApi,
-  selector: NormalizedUuidOrSlug | undefined,
-): Promise<NormalizedUuidOrSlug | undefined> {
-  if (!selector) {
-    return undefined;
-  }
-
-  if (selector.kind === "uuid") {
-    return selector;
-  }
-
-  const folders = await api.listFolders();
-  const resolved = resolveFolder(folders, selector);
-
-  if (typeof resolved.id !== "string" || resolved.id.length === 0) {
-    throw new CliError(
-      "invalid_cli_usage",
-      `Folder "${selector.value}" is missing an id in the API response.`,
-    );
-  }
-
-  return { kind: "uuid", value: resolved.id };
-}
-
-function toTableRows(data: unknown): Record<string, unknown>[] {
-  if (Array.isArray(data)) {
-    return data.map((entry) => (isJsonObject(entry) ? entry : { value: entry }));
-  }
-
-  if (isJsonObject(data)) {
-    return [data];
-  }
-
-  return [{ value: data }];
-}
-
-function emitTable(stdout: CommandIo, data: unknown): void {
-  printTable(toTableRows(data), undefined, stdout);
-}
-
-function folderRows(folders: readonly ApiAutomationFolder[]): Record<string, unknown>[] {
-  return folders.map((folder) => ({
-    id: folder.id ?? "",
-    name: folder.name ?? "",
-    automationCount: folder.automationCount ?? "",
-  }));
-}
-
-function automationRows(automations: readonly ApiAutomation[]): Record<string, unknown>[] {
-  return automations.map((automation) => ({
-    id: automation.id ?? "",
-    name: automation.name ?? "",
-    status: automation.status ?? "",
-    triggerType:
-      isJsonObject(automation.trigger) && typeof automation.trigger.type === "string"
-        ? automation.trigger.type
-        : "",
-    actionCount: Array.isArray(automation.actions) ? automation.actions.length : "",
-    ...folderColumns(automation.folder),
-  }));
-}
-
-function actionRows(actions: readonly ApiAutomationAction[]): Record<string, unknown>[] {
-  return actions.map((action) => ({
-    id: action.id ?? "",
-    name: action.name ?? "",
-    type: action.type ?? "",
-  }));
-}
-
-function pluginRows(plugins: readonly ApiAutomationPlugin[]): Record<string, unknown>[] {
-  return plugins.map((plugin) => ({
-    id: plugin.id ?? "",
-    name: plugin.name ?? "",
-    version: plugin.version ?? "",
-  }));
-}
-
-function connectionRows(
-  connections: readonly ApiAutomationConnection[],
-): Record<string, unknown>[] {
-  return connections.map((connection) => ({
-    id: connection.id ?? "",
-    name: connection.name ?? "",
-    type: connection.type ?? "",
-    scope: connection.scope ?? "",
-    active: connection.active ?? "",
-  }));
-}
-
-function buildFolderMutationInput(
-  options: FolderMutationCommandOptions,
-  requireName: boolean,
-): Record<string, unknown> {
-  const input: Record<string, unknown> = {};
-
-  if (options.name !== undefined) {
-    input.name = options.name;
-  }
-
-  if (requireName && typeof input.name !== "string") {
-    throw new CliError("invalid_cli_usage", 'Provide folder name via "--name".');
-  }
-
-  if (!requireName && isEmptyObject(input)) {
-    throw new CliError("invalid_cli_usage", 'Provide folder updates via "--name".');
-  }
-
-  return input;
-}
-
-function buildTriggerInput(
-  options: TriggerPayloadCommandOptions,
-  mode: "optional" | "required",
-): SetAutomationTriggerInput | undefined {
-  const input = {
-    ...readJsonObjectOption(options.raw, options.rawFile, "--raw", "--raw-file"),
-  } as Record<string, unknown>;
-
-  const config = isJsonObject(input.config) ? { ...input.config } : {};
-
-  if (options.triggerType !== undefined) {
-    input.type = options.triggerType;
-  }
-
-  if (options.cron !== undefined) {
-    config.cronExpression = options.cron;
-  }
-
-  if (options.triggerSchema !== undefined) {
-    config.schemaId = options.triggerSchema;
-  }
-
-  if ((options.triggerField?.length ?? 0) > 0) {
-    config.fieldIds = [...(options.triggerField ?? [])];
-  }
-
-  const conditions = readConditions(options.condition, options.conditionJson, "--condition-json");
-  if (conditions.length > 0) {
-    config.conditions = conditions;
-  }
-
-  if (options.webhookEndpointId !== undefined) {
-    config.webhookEndpointId = options.webhookEndpointId;
-  }
-
-  if (!isEmptyObject(config)) {
-    if (Array.isArray(config.conditions)) {
-      config.conditions = normalizeAutomationConditions(
-        config.conditions,
-        "trigger condition",
-        { allowSource: false },
-      );
-    }
-
-    input.config = config;
-  }
-
-  if (isEmptyObject(input)) {
-    if (mode === "optional") {
-      return undefined;
-    }
-
-    throw new CliError(
-      "invalid_cli_usage",
-      'Provide trigger input via "--trigger-type", trigger flags, "--raw", or "--raw-file".',
-    );
-  }
-
-  return input as SetAutomationTriggerInput;
-}
-
-async function buildAutomationCreateInput(
-  api: AutomationsApi,
-  options: AutomationCreateCommandOptions,
-): Promise<CreateAutomationInput> {
-  const input = {
-    ...readJsonObjectOption(options.raw, options.rawFile, "--raw", "--raw-file"),
-  } as Record<string, unknown>;
-
-  if (options.name !== undefined) {
-    input.name = options.name;
-  }
-
-  if (options.description !== undefined) {
-    input.description = options.description;
-  }
-
-  const folder = await resolveFolderSelector(api, options.folder);
-  if (folder) {
-    input.folderId = folder.value;
-  }
-
-  const trigger = buildTriggerInput(options, "optional");
-  if (trigger) {
-    input.trigger = trigger;
-  }
-
-  if (typeof input.name !== "string" || input.name.trim().length === 0) {
-    throw new CliError("invalid_cli_usage", 'Provide automation name via "--name".');
-  }
-
-  return input as CreateAutomationInput;
-}
-
-async function buildAutomationUpdateInput(
-  api: AutomationsApi,
-  options: AutomationUpdateCommandOptions,
-): Promise<UpdateAutomationInput> {
-  const raw = readJsonObjectOption(options.raw, options.rawFile, "--raw", "--raw-file");
-  const { set: rawSet, unset: rawUnset } = splitRawPatchPayload(raw, "raw automation update payload");
-  const setPayload: JsonObject = { ...rawSet };
-
-  if (options.name !== undefined) {
-    setPayload.name = options.name;
-  }
-
-  if (options.description !== undefined) {
-    setPayload.description = options.description;
-  }
-
-  const folder = await resolveFolderSelector(api, options.folder);
-  if (folder) {
-    setPayload.folderId = folder.value;
-  }
-
-  const unsetPayload = rawUnset.filter((path) => !hasSetPath(setPayload, path));
-  const input: UpdateAutomationInput = {};
-
-  if (!isEmptyObject(setPayload)) {
-    input.set = setPayload;
-  }
-
-  if (unsetPayload.length > 0) {
-    input.unset = [...new Set(unsetPayload)];
-  }
-
-  if (isEmptyObject(input as object)) {
-    throw new CliError(
-      "invalid_cli_usage",
-      'Provide automation updates via "--name", "--description", "--folder", "--raw", or "--raw-file".',
-    );
-  }
-
-  return input as UpdateAutomationInput;
-}
-
-function buildActionInput(
-  options: ActionMutationCommandOptions,
-  mode: "create" | "update",
-): MutationAutomationActionInput {
-  const input = {
-    ...readJsonObjectOption(options.raw, options.rawFile, "--raw", "--raw-file"),
-  } as Record<string, unknown>;
-
-  const config = isJsonObject(input.config) ? { ...input.config } : {};
-  const mappings = mergeMappings(options.map, options.mapJson);
-  const headers = parseStringAssignments(options.header);
-  const variables = parseStringAssignments(options.var);
-  const args = mergeMappings(options.arg, options.argJson);
-  const body = readJsonValueOption(options.body, options.bodyFile, "--body", "--body-file");
-
-  if (options.type !== undefined) {
-    input.type = options.type;
-  }
-
-  if (options.name !== undefined) {
-    input.name = options.name;
-  }
-
-  if (options.targetSchema !== undefined) {
-    config.targetSchemaId = options.targetSchema;
-  }
-
-  if (options.to !== undefined) {
-    mappings.recipients = options.to;
-  }
-
-  if (options.subject !== undefined) {
-    mappings.subject = options.subject;
-  }
-
-  if (options.message !== undefined) {
-    mappings.body = options.message;
-  }
-
-  if (!isEmptyObject(mappings)) {
-    config.fieldMapping = mappings;
-  }
-
-  const conditions = readConditions(options.condition, options.conditionJson, "--condition-json");
-  if (conditions.length > 0) {
-    config.conditions = conditions;
-  }
-
-  if (options.useTriggerRecord === true) {
-    config.useTriggerRecord = true;
-  }
-
-  if (options.method !== undefined) {
-    config.method = options.method.toUpperCase();
-  }
-
-  if (options.url !== undefined) {
-    config.url = options.url;
-  }
-
-  if (!isEmptyObject(headers)) {
-    config.headers = headers;
-  }
-
-  if (body !== undefined) {
-    config.body = body;
-  }
-
-  if (options.contentType !== undefined) {
-    config.contentType = options.contentType;
-  }
-
-  if (options.timeoutMs !== undefined) {
-    config.timeoutMs = options.timeoutMs;
-  }
-
-  if (!isEmptyObject(variables)) {
-    config.variables = variables;
-  }
-
-  if (options.authMode !== undefined) {
-    config.authMode = options.authMode;
-  }
-
-  if (options.connection !== undefined) {
-    config.connectionId = options.connection;
-  }
-
-  if (options.plugin !== undefined) {
-    config.pluginId = options.plugin;
-  }
-
-  if (!isEmptyObject(args)) {
-    config.pluginArgs = args;
-  }
-
-  if (options.documentTemplate !== undefined) {
-    config.documentTemplateId = options.documentTemplate;
-  }
-
-  if (options.targetFileField !== undefined) {
-    config.targetFileFieldId = options.targetFileField;
-  }
-
-  if (!isEmptyObject(config)) {
-    if (isJsonObject(config.fieldMapping)) {
-      config.fieldMapping = normalizeAutomationFieldMapping(
-        config.fieldMapping,
-        "field mapping",
-      );
-    }
-
-    if (Array.isArray(config.conditions)) {
-      config.conditions = normalizeAutomationConditions(
-        config.conditions,
-        "action condition",
-        { allowSource: true },
-      );
-    }
-
-    if (config.useTriggerRecord === true) {
-      delete config.conditions;
-    }
-
-    input.config = config;
-  }
-
-  if (mode === "create" && typeof input.type !== "string") {
-    throw new CliError("invalid_cli_usage", 'Provide action type via "--type" or "--raw".');
-  }
-
-  if (isEmptyObject(input)) {
-    throw new CliError(
-      "invalid_cli_usage",
-      'Provide action input via flags, "--raw", or "--raw-file".',
-    );
-  }
-
-  return input as MutationAutomationActionInput;
-}
-
-function buildFlowInput(options: FlowSetCommandOptions): SetAutomationFlowInput {
-  const input = {
-    ...readJsonObjectOption(options.raw, options.rawFile, "--raw", "--raw-file"),
-  } as Record<string, unknown>;
-
-  if ((options.entry?.length ?? 0) > 0) {
-    input.entryActionIds = [...(options.entry ?? [])];
-  }
-
-  if ((options.transition?.length ?? 0) > 0) {
-    input.transitions = (options.transition ?? []).map(parseTransition);
-  }
-
-  if (isEmptyObject(input)) {
-    throw new CliError(
-      "invalid_cli_usage",
-      'Provide flow input via "--entry", "--transition", "--raw", or "--raw-file".',
-    );
-  }
-
-  return input as SetAutomationFlowInput;
-}
-
-function readWebhookFieldMappings(options: WebhookSetCommandOptions): JsonValue[] {
-  const mappings: JsonValue[] = [];
-
-  for (const value of options.fieldMapping ?? []) {
-    mappings.push(parseJsonValue(value, "--field-mapping"));
-  }
-
-  for (const filePath of options.fieldMappingFile ?? []) {
-    mappings.push(
-      parseJsonValue(
-        readTextFile(filePath, "--field-mapping-file"),
-        `--field-mapping-file ${filePath}`,
-      ),
-    );
-  }
-
-  return mappings;
-}
-
-function buildWebhookInput(options: WebhookSetCommandOptions): SetAutomationWebhookInput {
-  const input = {
-    ...readJsonObjectOption(options.raw, options.rawFile, "--raw", "--raw-file"),
-  } as Record<string, unknown>;
-
-  if (options.active === true) {
-    input.active = true;
-  }
-
-  if (options.idempotencyKeyPath !== undefined) {
-    input.idempotencyKeyJsonPath = options.idempotencyKeyPath;
-  }
-
-  if (options.eventTypePath !== undefined) {
-    input.eventTypeJsonPath = options.eventTypePath;
-  }
-
-  if ((options.allowedEventType?.length ?? 0) > 0) {
-    input.allowedEventTypes = [...(options.allowedEventType ?? [])];
-  }
-
-  const fieldMappings = readWebhookFieldMappings(options);
-  if (fieldMappings.length > 0) {
-    input.fieldMappings = fieldMappings;
-  }
-
-  if (isEmptyObject(input)) {
-    throw new CliError(
-      "invalid_cli_usage",
-      'Provide webhook input via flags, "--raw", or "--raw-file".',
-    );
-  }
-
-  return input as SetAutomationWebhookInput;
-}
-
-function buildConnectionCreateInput(
-  options: ConnectionCreateCommandOptions,
-): CreateAutomationConnectionInput {
-  const input = {
-    ...readJsonObjectOption(options.raw, options.rawFile, "--raw", "--raw-file"),
-  } as Record<string, unknown>;
-
-  if (options.name !== undefined) {
-    input.name = options.name;
-  }
-
-  if (options.type !== undefined) {
-    input.type = options.type;
-  }
-
-  if (options.scope !== undefined) {
-    input.scope = options.scope;
-  }
-
-  if (options.ownerMember !== undefined) {
-    input.ownerMemberId = options.ownerMember;
-  }
-
-  const config = readJsonValueOption(options.config, options.configFile, "--config", "--config-file");
-  if (config !== undefined) {
-    if (!isJsonObject(config)) {
-      throw new CliError(
-        "invalid_cli_usage",
-        'Expected "--config" or "--config-file" to contain a JSON object.',
-      );
-    }
-
-    input.config = config;
-  }
-
-  const secrets = parseStringAssignments(options.secret);
-  if (!isEmptyObject(secrets)) {
-    input.secret = secrets;
-  }
-
-  if (options.active === true) {
-    input.active = true;
-  }
-
-  if (typeof input.name !== "string") {
-    throw new CliError("invalid_cli_usage", 'Provide connection name via "--name".');
-  }
-
-  if (typeof input.type !== "string") {
-    throw new CliError("invalid_cli_usage", 'Provide connection type via "--type".');
-  }
-
-  if (typeof input.scope !== "string") {
-    throw new CliError("invalid_cli_usage", 'Provide connection scope via "--scope".');
-  }
-
-  return input as CreateAutomationConnectionInput;
-}
-
-function buildConnectionUpdateInput(
-  options: ConnectionUpdateCommandOptions,
-): UpdateAutomationConnectionInput {
-  const input = {
-    ...readJsonObjectOption(options.raw, options.rawFile, "--raw", "--raw-file"),
-  } as UpdateAutomationConnectionInput;
-  const setPayload = readRawSetPayload(input as JsonObject, "raw connection update payload");
-
-  for (const value of options.set ?? []) {
-    const assignment = parseKeyValue(value);
-
-    if (assignment.key.startsWith("config.")) {
-      setNestedPath(setPayload, assignment.key.split(".").filter(Boolean), assignment.value);
-      continue;
-    }
-
-    setPayload[assignment.key] = assignment.value;
-  }
-
-  if (!isEmptyObject(setPayload)) {
-    input.set = setPayload;
-  }
-
-  const unsetPayload = [
-    ...readRawUnsetPayload(input as JsonObject, "raw connection update payload"),
-    ...(options.unset ?? []),
-  ].filter((path) => !hasSetPath(setPayload, path));
-
-  if (unsetPayload.length > 0) {
-    input.unset = [...new Set(unsetPayload)];
-  } else {
-    delete input.unset;
-  }
-
-  if (isEmptyObject(input as object)) {
-    throw new CliError(
-      "invalid_cli_usage",
-      'Provide connection updates via "--set", "--unset", "--raw", or "--raw-file".',
-    );
-  }
-
-  return input as UpdateAutomationConnectionInput;
-}
-
-function addTriggerPayloadOptions(command: Command): Command {
-  return command
-    .option("--trigger-type <type>", "trigger type")
-    .option("--cron <expression>", "cron expression for scheduled triggers")
-    .option("--trigger-schema <uuid>", "schema id for record-based triggers")
-    .option(
-      "--trigger-field <uuid>",
-      "field id for record_changed triggers",
-      collectValues,
-      [],
-    )
-    .option(
-      "--condition <field:comparator:value>",
-      "trigger condition (use field:comparator for comparators without value: chg, ie, ine)",
-      collectValues,
-      [],
-    )
-    .option(
-      "--condition-json <json>",
-      "trigger condition as JSON",
-      collectValues,
-      [],
-    )
-    .option("--webhook-endpoint-id <uuid>", "webhook endpoint id")
-    .option("--raw <json>", "raw trigger JSON payload")
-    .option("--raw-file <path>", "path to raw trigger JSON payload");
-}
-
-const ACTION_TYPES_HELP = `
-Action types and their flags:
-  create_record      --target-schema, --map, --map-json
-  update_record      --target-schema, --use-trigger-record, --map,
-                     --condition, --condition-json
-  search_records     --target-schema, --condition, --condition-json
-  send_message       --to, --subject, --message
-                     (--map / --map-json also accepted for extra keys)
-  http_request       --method, --url, --header, --body, --content-type,
-                     --timeout-ms, --var, --auth-mode, --connection
-  execute_plugin     --plugin, --arg, --arg-json
-  generate_document  --document-template, --target-schema, --target-file-field
-`;
-
-function addActionPayloadOptions(command: Command): Command {
-  return command
-    .option(
-      "--type <type>",
-      "action type (create_record|update_record|search_records|send_message|http_request|execute_plugin|generate_document)",
-    )
-    .option("--name <name>", "action name")
-    .option("--target-schema <uuid>", "target schema id")
-    .option("--map <field=value>", "field mapping", collectValues, [])
-    .option("--map-json <field=json>", "JSON field mapping", collectValues, [])
-    .option(
-      "--condition <field:comparator:value>",
-      "action condition (use field:comparator for comparators without value: ie, ine)",
-      collectValues,
-      [],
-    )
-    .option("--condition-json <json>", "action condition as JSON", collectValues, [])
-    .option("--use-trigger-record", "use the triggering record")
-    .option("--method <method>", "HTTP method")
-    .option("--url <url>", "HTTP target URL")
-    .option("--header <key=value>", "HTTP header", collectValues, [])
-    .option("--body <json>", "HTTP request body as JSON")
-    .option("--body-file <path>", "path to HTTP request body JSON")
-    .option("--content-type <type>", "HTTP content type")
-    .option(
-      "--timeout-ms <n>",
-      "HTTP timeout in milliseconds",
-      parseNonNegativeInteger,
-    )
-    .option("--var <key=value>", "HTTP variable", collectValues, [])
-    .option("--auth-mode <mode>", "HTTP auth mode")
-    .option("--connection <uuid>", "connection id for HTTP auth")
-    .option("--plugin <id>", "plugin id for execute_plugin")
-    .option("--arg <key=value>", "plugin argument", collectValues, [])
-    .option("--arg-json <key=json>", "plugin argument as JSON", collectValues, [])
-    .option("--to <recipient>", "send_message recipient (maps to fieldMapping.recipients)")
-    .option("--subject <text>", "send_message subject")
-    .option("--message <text>", "send_message body text (maps to fieldMapping.body)")
-    .option("--document-template <uuid>", "generate_document template id")
-    .option("--target-file-field <uuid>", "generate_document target FileField id")
-    .option("--raw <json>", "raw action JSON payload")
-    .option("--raw-file <path>", "path to raw action JSON payload")
-    .addHelpText("after", ACTION_TYPES_HELP);
-}
-
-export function registerAutomationsCommands(
-  program: Command,
-  options: RegisterAutomationsCommandsOptions = {},
-): void {
-  const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo(options.stdout);
-  const automations = program
-    .command("automations")
-    .description("Manage automations, triggers, actions, and connections");
-
-  const folders = automations
-    .command("folders")
-    .description("Manage automation folders (flat: a folder only has a name, no order or properties)");
-
-  folders
-    .command("list")
-    .description("List automation folders (non-root folders plus the root bucket, whose name is null)")
-    .action(async function action(this: Command) {
-      const { api, json } = createAutomationsApi(this, filePath);
-      const data = await api.listFolders();
-
-      if (json) {
-        emitJson(stdout, "automations folders list", data, filePath);
-        return;
-      }
-
-      printTable(folderRows(data), ["id", "name", "automationCount"], stdout);
-    });
-
-  folders
-    .command("create")
-    .description("Create an automation folder")
-    .requiredOption("--name <name>", "folder name")
-    .action(async function action(this: Command, commandOptions: FolderMutationCommandOptions) {
-      const { api, json, readOnly } = createAutomationsApi(this, filePath);
-      ensureWritable("automations folders create", readOnly, "write");
-      const data = await api.createFolder(buildFolderMutationInput(commandOptions, true));
-
-      if (json) {
-        emitJson(stdout, "automations folders create", data, filePath);
-        return;
-      }
-
-      writeLine(stdout, `Created automation folder "${String(data.name ?? commandOptions.name)}".`);
-    });
-
-  folders
-    .command("update")
-    .description("Update an automation folder")
-    .argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector)
-    .option("--name <name>", "folder name")
-    .action(async function action(
-      this: Command,
-      folder: NormalizedUuidOrSlug,
-      commandOptions: FolderMutationCommandOptions,
-    ) {
-      const { api, json, readOnly } = createAutomationsApi(this, filePath);
-      ensureWritable("automations folders update", readOnly, "write");
-      const resolvedFolder = await resolveFolderSelector(api, folder);
-
-      if (!resolvedFolder) {
-        throw new CliError("invalid_cli_usage", `Folder "${folder.value}" was not found.`);
-      }
-
-      const data = await api.updateFolder(
-        resolvedFolder,
-        buildFolderMutationInput(commandOptions, false),
-      );
-
-      if (json) {
-        emitJson(stdout, "automations folders update", data, filePath);
-        return;
-      }
-
-      writeLine(stdout, `Updated automation folder "${String(data.name ?? folder.value)}".`);
-    });
-
-  folders
-    .command("delete")
-    .description("Delete an automation folder")
-    .argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector)
-    .action(async function action(this: Command, folder: NormalizedUuidOrSlug) {
-      const { api, json, readOnly } = createAutomationsApi(this, filePath);
-      ensureWritable("automations folders delete", readOnly, "destructive");
-      const resolvedFolder = await resolveFolderSelector(api, folder);
-
-      if (!resolvedFolder) {
-        throw new CliError("invalid_cli_usage", `Folder "${folder.value}" was not found.`);
-      }
-
-      const data = await api.deleteFolder(resolvedFolder);
-
-      if (json) {
-        emitJson(stdout, "automations folders delete", data, filePath);
-        return;
-      }
-
-      writeLine(stdout, `Deleted automation folder "${folder.value}".`);
-    });
-
-  folders
-    .command("move")
-    .description("Move an automation into a folder")
-    .argument("<automation>", "automation UUID", parseUuidOrSlugSelector)
-    .requiredOption(
-      "--to <folder>",
-      "target folder UUID or exact name (use the root folder to move it out of any folder)",
-      parseUuidOrSlugSelector,
-    )
-    .action(async function action(
-      this: Command,
-      automation: NormalizedUuidOrSlug,
-      commandOptions: FolderMoveCommandOptions,
-    ) {
-      const { api, json, readOnly } = createAutomationsApi(this, filePath);
-      ensureWritable("automations folders move", readOnly, "write");
-
-      if (!commandOptions.to) {
-        throw new CliError("invalid_cli_usage", 'Provide target folder via "--to".');
-      }
-
-      const targetFolder = await resolveFolderSelector(api, commandOptions.to);
-
-      if (!targetFolder) {
-        throw new CliError(
-          "invalid_cli_usage",
-          `Folder "${commandOptions.to.value}" was not found.`,
-        );
-      }
-
-      const data = await api.moveAutomation({
-        automationId: automation.value,
-        targetFolderId: targetFolder.value,
-      });
-
-      if (json) {
-        emitJson(stdout, "automations folders move", data, filePath);
-        return;
-      }
-
-      writeLine(stdout, `Moved automation "${automation.value}" to folder "${targetFolder.value}".`);
-    });
-
-  automations
-    .command("list")
-    .description("List automations")
-    .option("--folder <folder>", "filter by folder UUID or exact name", parseUuidOrSlugSelector)
-    .option("--status <status>", "filter by status")
-    .option("--trigger-type <type>", "filter by trigger type")
-    .option("--action-type <type>", "filter by action type")
-    .option("--plugin <id>", "filter by plugin id")
-    .option("--search <text>", "search text")
-    .action(async function action(this: Command, commandOptions: AutomationListCommandOptions) {
-      const { api, json } = createAutomationsApi(this, filePath);
-      const folder = await resolveFolderSelector(api, commandOptions.folder);
-      const data = await api.listAutomations({
-        folderId: folder?.value,
-        status: commandOptions.status,
-        triggerType: commandOptions.triggerType,
-        actionType: commandOptions.actionType,
-        pluginId: commandOptions.plugin,
-        search: commandOptions.search,
-      });
-
-      if (json) {
-        emitJson(stdout, "automations list", data, filePath);
-        return;
-      }
-
-      printTable(
-        automationRows(data),
-        ["id", "name", "status", "triggerType", "actionCount", ...FOLDER_TABLE_KEYS],
-        stdout,
-      );
-    });
-
-  automations
-    .command("get")
-    .description("Get an automation")
-    .argument("<automation>", "automation UUID", parseUuidOrSlugSelector)
-    .action(async function action(this: Command, automation: NormalizedUuidOrSlug) {
-      const { api, json } = createAutomationsApi(this, filePath);
-      const data = await api.getAutomation(automation);
-
-      if (json) {
-        emitJson(stdout, "automations get", data, filePath);
-        return;
-      }
-
-      emitTable(stdout, data);
-    });
-
-  addTriggerPayloadOptions(
-    automations
-      .command("create")
-      .description("Create an automation")
-      .requiredOption("--name <name>", "automation name")
-      .option("--description <text>", "automation description")
-      .option("--folder <folder>", "folder UUID or exact name", parseUuidOrSlugSelector),
-  ).action(async function action(
-    this: Command,
-    commandOptions: AutomationCreateCommandOptions,
-  ) {
-    const { api, json, readOnly } = createAutomationsApi(this, filePath);
-    ensureWritable("automations create", readOnly, "write");
-    const data = await api.createAutomation(await buildAutomationCreateInput(api, commandOptions));
-
-    if (json) {
-      emitJson(stdout, "automations create", data, filePath);
-      return;
-    }
-
-    writeLine(stdout, `Created automation "${String(data.name ?? commandOptions.name)}".`);
-  });
-
-  automations
-    .command("update")
-    .description("Update an automation")
-    .argument("<automation>", "automation UUID", parseUuidOrSlugSelector)
-    .option("--name <name>", "automation name")
-    .option("--description <text>", "automation description")
-    .option("--folder <folder>", "folder UUID or exact name", parseUuidOrSlugSelector)
-    .option("--raw <json>", "raw automation JSON payload")
-    .option("--raw-file <path>", "path to raw automation JSON payload")
-    .action(async function action(
-      this: Command,
-      automation: NormalizedUuidOrSlug,
-      commandOptions: AutomationUpdateCommandOptions,
-    ) {
-      const { api, json, readOnly } = createAutomationsApi(this, filePath);
-      ensureWritable("automations update", readOnly, "write");
-      const data = await api.updateAutomation(
-        automation,
-        await buildAutomationUpdateInput(api, commandOptions),
-      );
-
-      if (json) {
-        emitJson(stdout, "automations update", data, filePath);
-        return;
-      }
-
-      writeLine(stdout, `Updated automation "${automation.value}".`);
-    });
-
-  automations
-    .command("delete")
-    .description("Delete an automation")
-    .argument("<automation>", "automation UUID", parseUuidOrSlugSelector)
-    .action(async function action(this: Command, automation: NormalizedUuidOrSlug) {
-      const { api, json, readOnly } = createAutomationsApi(this, filePath);
-      ensureWritable("automations delete", readOnly, "destructive");
-      const data = await api.deleteAutomation(automation);
-
-      if (json) {
-        emitJson(stdout, "automations delete", data, filePath);
-        return;
-      }
-
-      writeLine(stdout, `Deleted automation "${automation.value}".`);
-    });
-
-  automations
-    .command("activate")
-    .description("Activate an automation")
-    .argument("<automation>", "automation UUID", parseUuidOrSlugSelector)
-    .action(async function action(this: Command, automation: NormalizedUuidOrSlug) {
-      const { api, json, readOnly } = createAutomationsApi(this, filePath);
-      ensureWritable("automations activate", readOnly, "write");
-      const data = await api.activateAutomation(automation);
-
-      if (json) {
-        emitJson(stdout, "automations activate", data, filePath);
-        return;
-      }
-
-      writeLine(stdout, `Activated automation "${automation.value}".`);
-    });
-
-  automations
-    .command("deactivate")
-    .description("Deactivate an automation")
-    .argument("<automation>", "automation UUID", parseUuidOrSlugSelector)
-    .action(async function action(this: Command, automation: NormalizedUuidOrSlug) {
-      const { api, json, readOnly } = createAutomationsApi(this, filePath);
-      ensureWritable("automations deactivate", readOnly, "write");
-      const data = await api.deactivateAutomation(automation);
-
-      if (json) {
-        emitJson(stdout, "automations deactivate", data, filePath);
-        return;
-      }
-
-      writeLine(stdout, `Deactivated automation "${automation.value}".`);
-    });
-
-  const trigger = automations.command("trigger").description("Manage automation triggers");
-
-  trigger
-    .command("get")
-    .description("Get the trigger for an automation")
-    .argument("<automation>", "automation UUID", parseUuidOrSlugSelector)
-    .action(async function action(this: Command, automation: NormalizedUuidOrSlug) {
-      const { api, json } = createAutomationsApi(this, filePath);
-      const data = await api.getTrigger(automation);
-
-      if (json) {
-        emitJson(stdout, "automations trigger get", data, filePath);
-        return;
-      }
-
-      emitTable(stdout, data);
-    });
-
-  addTriggerPayloadOptions(
-    trigger
-      .command("set")
-      .description("Set the trigger for an automation")
-      .argument("<automation>", "automation UUID", parseUuidOrSlugSelector),
-  ).action(async function action(
-    this: Command,
-    automation: NormalizedUuidOrSlug,
-    commandOptions: TriggerPayloadCommandOptions,
-  ) {
-    const { api, json, readOnly } = createAutomationsApi(this, filePath);
-    ensureWritable("automations trigger set", readOnly, "write");
-    const data = await api.setTrigger(
-      automation,
-      buildTriggerInput(commandOptions, "required") as SetAutomationTriggerInput,
-    );
-
-    if (json) {
-      emitJson(stdout, "automations trigger set", data, filePath);
-      return;
-    }
-
-    writeLine(stdout, `Updated trigger for automation "${automation.value}".`);
-  });
-
-  const actions = automations.command("actions").description("Manage automation actions");
-
-  actions
-    .command("list")
-    .description("List automation actions")
-    .argument("<automation>", "automation UUID", parseUuidOrSlugSelector)
-    .action(async function action(this: Command, automation: NormalizedUuidOrSlug) {
-      const { api, json } = createAutomationsApi(this, filePath);
-      const data = await api.listActions(automation);
-
-      if (json) {
-        emitJson(stdout, "automations actions list", data, filePath);
-        return;
-      }
-
-      printTable(actionRows(data), ["id", "name", "type"], stdout);
-    });
-
-  addActionPayloadOptions(
-    actions
-      .command("add")
-      .description("Add an action to an automation")
-      .argument("<automation>", "automation UUID", parseUuidOrSlugSelector),
-  ).action(async function action(
-    this: Command,
-    automation: NormalizedUuidOrSlug,
-    commandOptions: ActionMutationCommandOptions,
-  ) {
-    const { api, json, readOnly } = createAutomationsApi(this, filePath);
-    ensureWritable("automations actions add", readOnly, "write");
-    const data = await api.addAction(automation, buildActionInput(commandOptions, "create"));
-
-    if (json) {
-      emitJson(stdout, "automations actions add", data, filePath);
-      return;
-    }
-
-    writeLine(stdout, `Added action to automation "${automation.value}".`);
-  });
-
-  addActionPayloadOptions(
-    actions
-      .command("update")
-      .description("Update an automation action")
-      .argument("<automation>", "automation UUID", parseUuidOrSlugSelector)
-      .argument("<action>", "action UUID"),
-  ).action(async function action(
-    this: Command,
-    automation: NormalizedUuidOrSlug,
-    actionId: string,
-    commandOptions: ActionMutationCommandOptions,
-  ) {
-    const { api, json, readOnly } = createAutomationsApi(this, filePath);
-    ensureWritable("automations actions update", readOnly, "write");
-    const data = await api.updateAction(automation, actionId, buildActionInput(commandOptions, "update"));
-
-    if (json) {
-      emitJson(stdout, "automations actions update", data, filePath);
-      return;
-    }
-
-    writeLine(stdout, `Updated action "${actionId}" on automation "${automation.value}".`);
-  });
-
-  actions
-    .command("delete")
-    .description("Delete an automation action")
-    .argument("<automation>", "automation UUID", parseUuidOrSlugSelector)
-    .argument("<action>", "action UUID")
-    .action(async function action(
-      this: Command,
-      automation: NormalizedUuidOrSlug,
-      actionId: string,
-    ) {
-      const { api, json, readOnly } = createAutomationsApi(this, filePath);
-      ensureWritable("automations actions delete", readOnly, "destructive");
-      const data = await api.deleteAction(automation, actionId);
-
-      if (json) {
-        emitJson(stdout, "automations actions delete", data, filePath);
-        return;
-      }
-
-      writeLine(stdout, `Deleted action "${actionId}" from automation "${automation.value}".`);
-    });
-
-  const flow = automations.command("flow").description("Manage automation flow wiring");
-
-  flow
-    .command("get")
-    .description("Get the flow for an automation")
-    .argument("<automation>", "automation UUID", parseUuidOrSlugSelector)
-    .action(async function action(this: Command, automation: NormalizedUuidOrSlug) {
-      const { api, json } = createAutomationsApi(this, filePath);
-      const data = await api.getFlow(automation);
-
-      if (json) {
-        emitJson(stdout, "automations flow get", data, filePath);
-        return;
-      }
-
-      emitTable(stdout, data);
-    });
-
-  flow
-    .command("set")
-    .description("Set the flow for an automation")
-    .argument("<automation>", "automation UUID", parseUuidOrSlugSelector)
-    .option("--entry <actionId>", "entry action id", collectValues, [])
-    .option("--transition <from:to>", "transition", collectValues, [])
-    .option("--raw <json>", "raw flow JSON payload")
-    .option("--raw-file <path>", "path to raw flow JSON payload")
-    .action(async function action(
-      this: Command,
-      automation: NormalizedUuidOrSlug,
-      commandOptions: FlowSetCommandOptions,
-    ) {
-      const { api, json, readOnly } = createAutomationsApi(this, filePath);
-      ensureWritable("automations flow set", readOnly, "write");
-      const data = await api.setFlow(automation, buildFlowInput(commandOptions));
-
-      if (json) {
-        emitJson(stdout, "automations flow set", data, filePath);
-        return;
-      }
-
-      writeLine(stdout, `Updated flow for automation "${automation.value}".`);
-    });
-
-  const webhook = automations.command("webhook").description("Manage automation webhook config");
-
-  webhook
-    .command("get")
-    .description("Get webhook configuration for an automation")
-    .argument("<automation>", "automation UUID", parseUuidOrSlugSelector)
-    .action(async function action(this: Command, automation: NormalizedUuidOrSlug) {
-      const { api, json } = createAutomationsApi(this, filePath);
-      const data = await api.getWebhook(automation);
-
-      if (json) {
-        emitJson(stdout, "automations webhook get", data, filePath);
-        return;
-      }
-
-      emitTable(stdout, data);
-    });
-
-  webhook
-    .command("set")
-    .description("Set webhook configuration for an automation")
-    .argument("<automation>", "automation UUID", parseUuidOrSlugSelector)
-    .option("--active", "activate webhook processing")
-    .option("--idempotency-key-path <jsonpath>", "idempotency key JSONPath")
-    .option("--event-type-path <jsonpath>", "event type JSONPath")
-    .option("--allowed-event-type <value>", "allowed event type", collectValues, [])
-    .option("--field-mapping <json>", "field mapping JSON", collectValues, [])
-    .option("--field-mapping-file <path>", "path to field mapping JSON", collectValues, [])
-    .option("--raw <json>", "raw webhook JSON payload")
-    .option("--raw-file <path>", "path to raw webhook JSON payload")
-    .action(async function action(
-      this: Command,
-      automation: NormalizedUuidOrSlug,
-      commandOptions: WebhookSetCommandOptions,
-    ) {
-      const { api, json, readOnly } = createAutomationsApi(this, filePath);
-      ensureWritable("automations webhook set", readOnly, "write");
-      const data = await api.setWebhook(automation, buildWebhookInput(commandOptions));
-
-      if (json) {
-        emitJson(stdout, "automations webhook set", data, filePath);
-        return;
-      }
-
-      writeLine(stdout, `Updated webhook for automation "${automation.value}".`);
-    });
-
-  webhook
-    .command("delete")
-    .description("Delete webhook configuration for an automation")
-    .argument("<automation>", "automation UUID", parseUuidOrSlugSelector)
-    .action(async function action(this: Command, automation: NormalizedUuidOrSlug) {
-      const { api, json, readOnly } = createAutomationsApi(this, filePath);
-      ensureWritable("automations webhook delete", readOnly, "destructive");
-      const data = await api.deleteWebhook(automation);
-
-      if (json) {
-        emitJson(stdout, "automations webhook delete", data, filePath);
-        return;
-      }
-
-      writeLine(stdout, `Deleted webhook for automation "${automation.value}".`);
-    });
-
-  const plugins = automations.command("plugins").description("Inspect automation plugins");
-
-  plugins
-    .command("list")
-    .description("List automation plugins")
-    .action(async function action(this: Command) {
-      const { api, json } = createAutomationsApi(this, filePath);
-      const data = await api.listPlugins();
-
-      if (json) {
-        emitJson(stdout, "automations plugins list", data, filePath);
-        return;
-      }
-
-      printTable(pluginRows(data), ["id", "name", "version"], stdout);
-    });
-
-  plugins
-    .command("get")
-    .description("Get an automation plugin")
-    .argument("<plugin>", "plugin id")
-    .action(async function action(this: Command, pluginId: string) {
-      const { api, json } = createAutomationsApi(this, filePath);
-      const data = await api.getPlugin(pluginId);
-
-      if (json) {
-        emitJson(stdout, "automations plugins get", data, filePath);
-        return;
-      }
-
-      emitTable(stdout, data);
-    });
-
-  const connections = automations
-    .command("connections")
-    .description("Manage automation connections");
-
-  connections
-    .command("list")
-    .description("List automation connections")
-    .action(async function action(this: Command) {
-      const { api, json } = createAutomationsApi(this, filePath);
-      const data = await api.listConnections();
-
-      if (json) {
-        emitJson(stdout, "automations connections list", data, filePath);
-        return;
-      }
-
-      printTable(connectionRows(data), ["id", "name", "type", "scope", "active"], stdout);
-    });
-
-  connections
-    .command("get")
-    .description("Get an automation connection")
-    .argument("<connection>", "connection UUID", parseUuidOrSlugSelector)
-    .action(async function action(this: Command, connection: NormalizedUuidOrSlug) {
-      const { api, json } = createAutomationsApi(this, filePath);
-      const data = await api.getConnection(connection);
-
-      if (json) {
-        emitJson(stdout, "automations connections get", data, filePath);
-        return;
-      }
-
-      emitTable(stdout, data);
-    });
-
-  connections
-    .command("create")
-    .description("Create an automation connection")
-    .requiredOption("--name <name>", "connection name")
-    .requiredOption("--type <type>", "connection type")
-    .requiredOption("--scope <scope>", "connection scope")
-    .option("--owner-member <uuid>", "owner member id")
-    .option("--config <json>", "connection config JSON object")
-    .option("--config-file <path>", "path to connection config JSON object")
-    .option("--secret <key=value>", "connection secret", collectValues, [])
-    .option("--active", "activate connection")
-    .option("--raw <json>", "raw connection JSON payload")
-    .option("--raw-file <path>", "path to raw connection JSON payload")
-    .action(async function action(this: Command, commandOptions: ConnectionCreateCommandOptions) {
-      const { api, json, readOnly } = createAutomationsApi(this, filePath);
-      ensureWritable("automations connections create", readOnly, "write");
-      const data = await api.createConnection(buildConnectionCreateInput(commandOptions));
-
-      if (json) {
-        emitJson(stdout, "automations connections create", data, filePath);
-        return;
-      }
-
-      writeLine(stdout, `Created connection "${String(data.name ?? commandOptions.name)}".`);
-    });
-
-  connections
-    .command("update")
-    .description("Update an automation connection")
-    .argument("<connection>", "connection UUID", parseUuidOrSlugSelector)
-    .option("--set <path=value>", "set a path to a string value", collectValues, [])
-    .option("--unset <path>", "unset a path", collectValues, [])
-    .option("--raw <json>", "raw connection patch JSON payload")
-    .option("--raw-file <path>", "path to raw connection patch JSON payload")
-    .action(async function action(
-      this: Command,
-      connection: NormalizedUuidOrSlug,
-      commandOptions: ConnectionUpdateCommandOptions,
-    ) {
-      const { api, json, readOnly } = createAutomationsApi(this, filePath);
-      ensureWritable("automations connections update", readOnly, "write");
-      const data = await api.updateConnection(connection, buildConnectionUpdateInput(commandOptions));
-
-      if (json) {
-        emitJson(stdout, "automations connections update", data, filePath);
-        return;
-      }
-
-      writeLine(stdout, `Updated connection "${connection.value}".`);
-    });
-
-  connections
-    .command("delete")
-    .description("Delete an automation connection")
-    .argument("<connection>", "connection UUID", parseUuidOrSlugSelector)
-    .action(async function action(this: Command, connection: NormalizedUuidOrSlug) {
-      const { api, json, readOnly } = createAutomationsApi(this, filePath);
-      ensureWritable("automations connections delete", readOnly, "destructive");
-      const data = await api.deleteConnection(connection);
-
-      if (json) {
-        emitJson(stdout, "automations connections delete", data, filePath);
-        return;
-      }
-
-      writeLine(stdout, `Deleted connection "${connection.value}".`);
-    });
-}