zinkee 0.1.44 → 0.1.45

package/src/commands/automations.test.ts

@@ -1,1030 +0,0 @@
-import { mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { Command } from "commander";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { registerAutomationsCommands } from "./automations.js";
-
-function createTempConfig(contents: string): string {
-  const dir = mkdtempSync(join(tmpdir(), "zinkee-automations-"));
-  const filePath = join(dir, "config.toml");
-  writeFileSync(filePath, contents, "utf8");
-  return filePath;
-}
-
-function createApiConfig(): string {
-  return createTempConfig(`
-default_profile = "prod"
-
-[profiles.prod]
-api_key = "automations-token-1234"
-base_url = "https://api.zinkee.test"
-`);
-}
-
-function createStdoutBuffer() {
-  let output = "";
-
-  return {
-    stdout: {
-      write(chunk: string) {
-        output += chunk;
-        return true;
-      },
-    },
-    read() {
-      return output;
-    },
-  };
-}
-
-function jsonResponse(body: unknown, status: number = 200): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: {
-      "content-type": "application/json",
-    },
-  });
-}
-
-function createFetchMock() {
-  const fetchMock = vi.fn<typeof fetch>();
-  vi.stubGlobal("fetch", fetchMock);
-  return fetchMock;
-}
-
-function buildAutomationsProgram(options: { configPath?: string; stdout?: { write(chunk: string): unknown } } = {}): Command {
-  const program = new Command();
-
-  program
-    .name("zinkee")
-    .description("CLI for Zinkee API v2")
-    .version("0.1.0")
-    .enablePositionalOptions()
-    .showHelpAfterError()
-    .option("--profile <name>", "select a profile from config")
-    .option("--base-url <url>", "override the configured base URL")
-    .option("--api-key <token>", "override the configured API key")
-    .option("--read-only", "run in read-only mode")
-    .option("--json", "emit JSON output");
-
-  registerAutomationsCommands(program, options);
-
-  return program;
-}
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-  vi.restoreAllMocks();
-});
-
-describe("automations commands", () => {
-  it("registers the automations command group", () => {
-    const program = buildAutomationsProgram();
-
-    expect(program.commands.some((command) => command.name() === "automations")).toBe(true);
-  });
-
-  it("moves an automation with the folder id in the body, not the path", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({ id: "folder-1", name: "Ops", isRoot: false }),
-    );
-    const program = buildAutomationsProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "automations",
-      "folders",
-      "move",
-      "11111111-1111-4111-a111-111111111111",
-      "--to",
-      "22222222-2222-4222-a222-222222222222",
-    ]);
-
-    expect(fetchMock.mock.calls[0]?.[0]).toBe(
-      "https://api.zinkee.test/api/v2/automation-folders/automations:move",
-    );
-    const init = fetchMock.mock.calls[0]?.[1];
-    expect(init?.method).toBe("POST");
-    expect(JSON.parse(String(init?.body))).toEqual({
-      automationId: "11111111-1111-4111-a111-111111111111",
-      targetFolderId: "22222222-2222-4222-a222-222222222222",
-    });
-  });
-
-  it("sets trigger payloads through the generic trigger flags", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        ok: true,
-      }),
-    );
-    const program = buildAutomationsProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "automations",
-      "trigger",
-      "set",
-      "automation-1",
-      "--trigger-type",
-      "record_changed",
-      "--trigger-schema",
-      "schema-1",
-      "--trigger-field",
-      "field-1",
-      "--trigger-field",
-      "field-2",
-      "--condition",
-      "status:eq:open",
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-
-    expect(fetchMock.mock.calls[0]?.[0]).toBe(
-      "https://api.zinkee.test/api/v2/automations/automation-1/trigger",
-    );
-    expect(init?.method).toBe("PUT");
-    expect(JSON.parse(String(init?.body))).toEqual({
-      type: "record_changed",
-      config: {
-        schemaId: "schema-1",
-        fieldIds: ["field-1", "field-2"],
-        conditions: [
-          {
-            field: "status",
-            comparator: "eq",
-            values: [
-              {
-                rawValue: "open",
-                source: null,
-              },
-            ],
-          },
-        ],
-      },
-    });
-    expect(JSON.parse(output.read())).toEqual({
-      data: {
-        ok: true,
-      },
-      meta: {
-        command: "automations trigger set",
-        configPath,
-      },
-    });
-  });
-
-  it("adds action payloads through the generic --type path", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        id: "action-1",
-      }),
-    );
-    const program = buildAutomationsProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "automations",
-      "actions",
-      "add",
-      "automation-1",
-      "--type",
-      "http_request",
-      "--name",
-      "Notify",
-      "--method",
-      "post",
-      "--url",
-      "https://example.com/hook",
-      "--header",
-      "authorization=Bearer token",
-      "--body",
-      '{"ok":true}',
-      "--content-type",
-      "application/json",
-      "--timeout-ms",
-      "5000",
-      "--var",
-      "env=prod",
-      "--connection",
-      "connection-1",
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-
-    expect(fetchMock.mock.calls[0]?.[0]).toBe(
-      "https://api.zinkee.test/api/v2/automations/automation-1/actions",
-    );
-    expect(init?.method).toBe("POST");
-    expect(JSON.parse(String(init?.body))).toEqual({
-      type: "http_request",
-      name: "Notify",
-      config: {
-        method: "POST",
-        url: "https://example.com/hook",
-        headers: {
-          authorization: "Bearer token",
-        },
-        body: {
-          ok: true,
-        },
-        contentType: "application/json",
-        timeoutMs: 5000,
-        variables: {
-          env: "prod",
-        },
-        connectionId: "connection-1",
-      },
-    });
-  });
-
-  it("maps record action field mappings to the backend fieldMapping contract", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ id: "action-1" }));
-    const program = buildAutomationsProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "automations",
-      "actions",
-      "add",
-      "automation-1",
-      "--type",
-      "create_record",
-      "--name",
-      "Create follow-up",
-      "--target-schema",
-      "schema-1",
-      "--map",
-      "status=pending",
-      "--map-json",
-      'meta={"source":"automation"}',
-    ]);
-
-    expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual({
-      type: "create_record",
-      name: "Create follow-up",
-      config: {
-        targetSchemaId: "schema-1",
-        fieldMapping: {
-          status: {
-            rawValue: "pending",
-            source: null,
-          },
-          meta: {
-            rawValue: {
-              source: "automation",
-            },
-            source: null,
-          },
-        },
-      },
-    });
-  });
-
-  it("maps plugin arguments to the backend pluginArgs contract", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ id: "action-1" }));
-    const program = buildAutomationsProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "automations",
-      "actions",
-      "add",
-      "automation-1",
-      "--type",
-      "execute_plugin",
-      "--name",
-      "Run plugin",
-      "--plugin",
-      "demo-plugin",
-      "--arg",
-      "mode=safe",
-      "--arg-json",
-      'payload={"dryRun":true}',
-    ]);
-
-    expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual({
-      type: "execute_plugin",
-      name: "Run plugin",
-      config: {
-        pluginId: "demo-plugin",
-        pluginArgs: {
-          mode: "safe",
-          payload: {
-            dryRun: true,
-          },
-        },
-      },
-    });
-  });
-
-  it("preserves source-based field mappings for record actions", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ id: "action-1" }));
-    const program = buildAutomationsProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "automations",
-      "actions",
-      "add",
-      "automation-1",
-      "--type",
-      "create_record",
-      "--name",
-      "Create from trigger",
-      "--target-schema",
-      "schema-1",
-      "--map-json",
-      'owner={"rawValue":null,"source":{"type":"TRIGGER","id":"f1e1d000-0000-0000-0000-000000000005"}}',
-    ]);
-
-    expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual({
-      type: "create_record",
-      name: "Create from trigger",
-      config: {
-        targetSchemaId: "schema-1",
-        fieldMapping: {
-          owner: {
-            rawValue: null,
-            source: {
-              type: "TRIGGER",
-              id: "f1e1d000-0000-0000-0000-000000000005",
-            },
-          },
-        },
-      },
-    });
-  });
-
-  it("maps search-record conditions to structured values", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ id: "action-1" }));
-    const program = buildAutomationsProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "automations",
-      "actions",
-      "add",
-      "automation-1",
-      "--type",
-      "search_records",
-      "--name",
-      "Search related",
-      "--target-schema",
-      "schema-1",
-      "--condition-json",
-      '{"field":"status","comparator":"eq","values":[{"rawValue":null,"source":{"type":"TRIGGER","id":"f1e1d000-0000-0000-0000-000000000005"}}]}',
-    ]);
-
-    expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual({
-      type: "search_records",
-      name: "Search related",
-      config: {
-        targetSchemaId: "schema-1",
-        conditions: [
-          {
-            field: "status",
-            comparator: "eq",
-            values: [
-              {
-                rawValue: null,
-                source: {
-                  type: "TRIGGER",
-                  id: "f1e1d000-0000-0000-0000-000000000005",
-                },
-              },
-            ],
-          },
-        ],
-      },
-    });
-  });
-
-  it("omits conditions when update_record uses the trigger record", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ id: "action-1" }));
-    const program = buildAutomationsProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "automations",
-      "actions",
-      "add",
-      "automation-1",
-      "--type",
-      "update_record",
-      "--name",
-      "Update trigger record",
-      "--target-schema",
-      "schema-1",
-      "--map",
-      "status=done",
-      "--condition",
-      "status:eq:open",
-      "--use-trigger-record",
-    ]);
-
-    expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual({
-      type: "update_record",
-      name: "Update trigger record",
-      config: {
-        targetSchemaId: "schema-1",
-        fieldMapping: {
-          status: {
-            rawValue: "done",
-            source: null,
-          },
-        },
-        useTriggerRecord: true,
-      },
-    });
-  });
-
-  it("builds send_message actions with wrapped fieldMapping (recipients/subject/body)", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ id: "action-1" }));
-    const program = buildAutomationsProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "automations",
-      "actions",
-      "add",
-      "automation-1",
-      "--type",
-      "send_message",
-      "--name",
-      "Notify customer",
-      "--to",
-      "customer@example.com",
-      "--subject",
-      "Your order status has changed",
-      "--message",
-      "Hello, your order is now processed.",
-    ]);
-
-    expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual({
-      type: "send_message",
-      name: "Notify customer",
-      config: {
-        fieldMapping: {
-          recipients: {
-            rawValue: "customer@example.com",
-            source: null,
-          },
-          subject: {
-            rawValue: "Your order status has changed",
-            source: null,
-          },
-          body: {
-            rawValue: "Hello, your order is now processed.",
-            source: null,
-          },
-        },
-      },
-    });
-  });
-
-  it("wraps send_message --map values in {rawValue, source} like other field mappings", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ id: "action-1" }));
-    const program = buildAutomationsProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "automations",
-      "actions",
-      "add",
-      "automation-1",
-      "--type",
-      "send_message",
-      "--name",
-      "Notify customer",
-      "--to",
-      "customer@example.com",
-      "--map-json",
-      'metadata={"orderId":"ORD-1"}',
-    ]);
-
-    expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual({
-      type: "send_message",
-      name: "Notify customer",
-      config: {
-        fieldMapping: {
-          recipients: {
-            rawValue: "customer@example.com",
-            source: null,
-          },
-          metadata: {
-            rawValue: { orderId: "ORD-1" },
-            source: null,
-          },
-        },
-      },
-    });
-  });
-
-  it("builds generate_document actions with template, schema, and file-field ids", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ id: "action-1" }));
-    const program = buildAutomationsProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "automations",
-      "actions",
-      "add",
-      "automation-1",
-      "--type",
-      "generate_document",
-      "--name",
-      "Generate invoice PDF",
-      "--document-template",
-      "6c08673e-f8a6-44d2-8c91-d09eca911f8f",
-      "--target-schema",
-      "68d2c7be-4392-42de-b5ae-625ad79cfc3c",
-      "--target-file-field",
-      "c8edbde8-a361-4e9f-a39a-2e88971f21a7",
-    ]);
-
-    expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual({
-      type: "generate_document",
-      name: "Generate invoice PDF",
-      config: {
-        documentTemplateId: "6c08673e-f8a6-44d2-8c91-d09eca911f8f",
-        targetSchemaId: "68d2c7be-4392-42de-b5ae-625ad79cfc3c",
-        targetFileFieldId: "c8edbde8-a361-4e9f-a39a-2e88971f21a7",
-      },
-    });
-  });
-
-  it("accepts the field:comparator literal form for no-value comparators", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ ok: true }));
-    const program = buildAutomationsProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "automations",
-      "trigger",
-      "set",
-      "automation-1",
-      "--trigger-type",
-      "record_changed",
-      "--trigger-schema",
-      "schema-1",
-      "--trigger-field",
-      "field-1",
-      "--condition",
-      "field-1:chg",
-    ]);
-
-    expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual({
-      type: "record_changed",
-      config: {
-        schemaId: "schema-1",
-        fieldIds: ["field-1"],
-        conditions: [
-          {
-            field: "field-1",
-            comparator: "chg",
-            values: [],
-          },
-        ],
-      },
-    });
-  });
-
-  it("accepts empty condition-json values for no-value comparators", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ ok: true }));
-    const program = buildAutomationsProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "automations",
-      "trigger",
-      "set",
-      "automation-1",
-      "--trigger-type",
-      "record_changed",
-      "--trigger-schema",
-      "schema-1",
-      "--trigger-field",
-      "field-1",
-      "--condition-json",
-      '{"field":"field-1","comparator":"ie","values":[]}',
-    ]);
-
-    expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual({
-      type: "record_changed",
-      config: {
-        schemaId: "schema-1",
-        fieldIds: ["field-1"],
-        conditions: [
-          {
-            field: "field-1",
-            comparator: "ie",
-            values: [],
-          },
-        ],
-      },
-    });
-  });
-
-  it("rejects the field:comparator literal form for comparators that need a value", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    const program = buildAutomationsProgram({ configPath, stdout: output.stdout });
-
-    await expect(
-      program.parseAsync([
-        "node",
-        "zinkee",
-        "--json",
-        "automations",
-        "trigger",
-        "set",
-        "automation-1",
-        "--trigger-type",
-        "record_changed",
-        "--trigger-schema",
-        "schema-1",
-        "--trigger-field",
-        "field-1",
-        "--condition",
-        "field-1:eq",
-      ]),
-    ).rejects.toThrowError(/field:comparator for comparators without value/);
-
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("rejects empty condition-json values for comparators that need a value", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    const program = buildAutomationsProgram({ configPath, stdout: output.stdout });
-
-    await expect(
-      program.parseAsync([
-        "node",
-        "zinkee",
-        "--json",
-        "automations",
-        "trigger",
-        "set",
-        "automation-1",
-        "--trigger-type",
-        "record_changed",
-        "--trigger-schema",
-        "schema-1",
-        "--trigger-field",
-        "field-1",
-        "--condition-json",
-        '{"field":"field-1","comparator":"eq","values":[]}',
-      ]),
-    ).rejects.toThrowError(/non-empty "values" array/);
-
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("rejects source-based trigger conditions", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    const program = buildAutomationsProgram({ configPath, stdout: output.stdout });
-
-    await expect(
-      program.parseAsync([
-        "node",
-        "zinkee",
-        "--json",
-        "automations",
-        "trigger",
-        "set",
-        "automation-1",
-        "--trigger-type",
-        "record_changed",
-        "--trigger-schema",
-        "schema-1",
-        "--trigger-field",
-        "field-1",
-        "--condition-json",
-        '{"field":"status","comparator":"eq","values":[{"rawValue":null,"source":{"type":"TRIGGER","id":"f1e1d000-0000-0000-0000-000000000005"}}]}',
-      ]),
-    ).rejects.toThrowError('Expected trigger condition 1 value 1 to use only literal "rawValue" values.');
-
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("sets flow payloads from repeated entry and transition flags", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        id: "automation-1",
-      }),
-    );
-    const program = buildAutomationsProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "automations",
-      "flow",
-      "set",
-      "automation-1",
-      "--entry",
-      "action-1",
-      "--entry",
-      "action-2",
-      "--transition",
-      "action-1:action-2",
-      "--transition",
-      "action-2:action-3",
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-
-    expect(fetchMock.mock.calls[0]?.[0]).toBe(
-      "https://api.zinkee.test/api/v2/automations/automation-1/flow",
-    );
-    expect(init?.method).toBe("PUT");
-    expect(JSON.parse(String(init?.body))).toEqual({
-      entryActionIds: ["action-1", "action-2"],
-      transitions: [
-        { fromActionId: "action-1", toActionId: "action-2" },
-        { fromActionId: "action-2", toActionId: "action-3" },
-      ],
-    });
-  });
-
-  it("blocks write operations in read-only mode", async () => {
-    const configPath = createApiConfig();
-    const fetchMock = createFetchMock();
-    const program = buildAutomationsProgram({ configPath });
-
-    await expect(
-      program.parseAsync([
-        "node",
-        "zinkee",
-        "--read-only",
-        "automations",
-        "trigger",
-        "set",
-        "automation-1",
-        "--trigger-type",
-        "scheduled",
-        "--cron",
-        "0 * * * *",
-      ]),
-    ).rejects.toThrowError(
-      'Command "automations trigger set" is not allowed in read-only mode.',
-    );
-
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("updates automations using the backend patch contract with set and unset", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        id: "automation-1",
-        name: "Lead welcome",
-      }),
-    );
-    const program = buildAutomationsProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "automations",
-      "update",
-      "automation-1",
-      "--name",
-      "Lead welcome",
-      "--raw",
-      '{"description":"Updated automation","unset":["archivedAt"]}',
-    ]);
-
-    expect(fetchMock.mock.calls[0]?.[0]).toBe(
-      "https://api.zinkee.test/api/v2/automations/automation-1",
-    );
-    expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual({
-      set: {
-        description: "Updated automation",
-        name: "Lead welcome",
-      },
-      unset: ["archivedAt"],
-    });
-    expect(JSON.parse(output.read())).toEqual({
-      data: {
-        id: "automation-1",
-        name: "Lead welcome",
-      },
-      meta: {
-        command: "automations update",
-        configPath,
-      },
-    });
-  });
-
-  it("updates connections deterministically for nested config paths", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        id: "connection-1",
-        name: "Primary",
-      }),
-    );
-    const program = buildAutomationsProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "automations",
-      "connections",
-      "update",
-      "connection-1",
-      "--set",
-      "config.baseUrl=https://api.example.com",
-      "--set",
-      "config.auth.token=secret",
-      "--set",
-      "name=Primary",
-      "--unset",
-      "config.legacy",
-      "--raw",
-      '{"set":{"config":{"region":"eu"}}, "unset":["config.baseUrl","oldField"]}',
-    ]);
-
-    expect(fetchMock.mock.calls[0]?.[0]).toBe(
-      "https://api.zinkee.test/api/v2/automation-connections/connection-1",
-    );
-    expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual({
-      set: {
-        config: {
-          region: "eu",
-          baseUrl: "https://api.example.com",
-          auth: {
-            token: "secret",
-          },
-        },
-        name: "Primary",
-      },
-      unset: ["oldField", "config.legacy"],
-    });
-  });
-
-  it("uses backend webhook endpoint field names", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ id: "webhook-1" }));
-    const program = buildAutomationsProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "automations",
-      "webhook",
-      "set",
-      "automation-1",
-      "--active",
-      "--idempotency-key-path",
-      "$.id",
-      "--event-type-path",
-      "$.type",
-      "--allowed-event-type",
-      "frontend.demo.created",
-      "--field-mapping",
-      '{"variable":"external_id","jsonPath":"$.data.id"}',
-    ]);
-
-    expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual({
-      active: true,
-      idempotencyKeyJsonPath: "$.id",
-      eventTypeJsonPath: "$.type",
-      allowedEventTypes: ["frontend.demo.created"],
-      fieldMappings: [
-        {
-          variable: "external_id",
-          jsonPath: "$.data.id",
-        },
-      ],
-    });
-  });
-
-  it("uses secret instead of secrets when creating connections", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(jsonResponse({ id: "connection-1" }));
-    const program = buildAutomationsProgram({ configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "automations",
-      "connections",
-      "create",
-      "--name",
-      "ERP API Key",
-      "--type",
-      "api_key",
-      "--scope",
-      "workspace",
-      "--config",
-      '{"headerName":"Authorization"}',
-      "--secret",
-      "apiKey=super-secret",
-      "--active",
-    ]);
-
-    expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual({
-      name: "ERP API Key",
-      type: "api_key",
-      scope: "workspace",
-      config: {
-        headerName: "Authorization",
-      },
-      secret: {
-        apiKey: "super-secret",
-      },
-      active: true,
-    });
-  });
-});