@zapier/trello-connector 0.0.0 → 0.1.0

package/scripts/createCard.ts

@@ -0,0 +1,266 @@
+#!/usr/bin/env node
+// Authored by the implementation agent: multi-step card create (POST /cards + optional
+// member/label/attachment/checklist/custom-field follow-ups) — outside codegen's single-call model.
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+import {
+  TRELLO_BASE,
+  TRELLO_ID_REGEX,
+  trelloError,
+  trelloFormBody,
+  trelloFormHeaders,
+} from "../lib/trello.ts";
+
+const cardOutputSchema = z.object({
+  id: z.string().regex(TRELLO_ID_REGEX),
+  idShort: z.number().int().nullable().optional(),
+  name: z.string(),
+  desc: z.string().nullable().optional(),
+  idBoard: z.string(),
+  idList: z.string(),
+  shortUrl: z.string().nullable().optional(),
+  url: z.string(),
+  due: z.union([z.string().datetime({ offset: true }), z.null()]).optional(),
+  start: z.union([z.string().datetime({ offset: true }), z.null()]).optional(),
+  closed: z.boolean(),
+  idMembers: z.array(z.string()).optional(),
+  idLabels: z.array(z.string()).optional(),
+  labels: z
+    .array(
+      z.object({
+        id: z.string(),
+        name: z.string().nullable().optional(),
+        color: z.string().nullable().optional(),
+      }),
+    )
+    .optional(),
+  dateLastActivity: z.string().datetime({ offset: true }).nullable().optional(),
+  customFields: z.record(z.string(), z.json()).optional(),
+});
+
+const inputSchema = z
+  .object({
+    idList: z
+      .string()
+      .describe("Destination list id. Resolve via listLists or findList."),
+    name: z.string().describe("Card title."),
+    desc: z.string().describe("Card description (Trello Markdown).").optional(),
+    pos: z
+      .union([z.enum(["top", "bottom"]), z.number()])
+      .describe("Position in the destination list.")
+      .optional(),
+    due: z.string().datetime({ offset: true }).optional(),
+    start: z.string().datetime({ offset: true }).optional(),
+    idMembers: z
+      .array(z.string())
+      .describe("Member ids to assign. Resolve via listBoardMembers.")
+      .optional(),
+    idLabels: z
+      .array(z.string())
+      .describe("Label ids to add. Resolve via listLabels or findLabel.")
+      .optional(),
+    attachmentUrl: z
+      .string()
+      .url()
+      .describe("URL attachment to add after create.")
+      .optional(),
+    attachmentFileUrl: z
+      .string()
+      .url()
+      .describe("Remote file URL to fetch and upload as attachment.")
+      .optional(),
+    checklistName: z
+      .string()
+      .describe("Create a checklist with this name after card create.")
+      .optional(),
+    checklistItems: z
+      .array(z.string())
+      .describe("Checklist item names for the new checklist.")
+      .optional(),
+    customFieldValues: z
+      .record(z.string(), z.json())
+      .describe(
+        "Custom field values keyed by field name. Resolve names via listCustomFields.",
+      )
+      .optional(),
+    address: z.string().optional(),
+    coordinates: z.string().describe("latitude,longitude").optional(),
+    locationName: z.string().optional(),
+  })
+  .strict();
+
+const definition = defineTool({
+  name: "createCard",
+  title: "Create Card",
+  description:
+    "Create a card on a list with optional members, labels, attachments, checklist, and custom fields. Resolve idList via listLists or findList first.",
+  inputSchema,
+  outputSchema: cardOutputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const createFields: Record<string, string | number> = {
+      name: input.name,
+      idList: input.idList,
+    };
+    if (input.desc !== undefined)
+      createFields.desc = input.desc.slice(0, 16383);
+    if (input.pos !== undefined) createFields.pos = input.pos;
+    if (input.due !== undefined) createFields.due = input.due;
+    if (input.start !== undefined) createFields.start = input.start;
+    if (input.address !== undefined) createFields.address = input.address;
+    if (input.coordinates !== undefined)
+      createFields.coordinates = input.coordinates;
+    if (input.locationName !== undefined)
+      createFields.locationName = input.locationName;
+    if (input.idLabels?.length)
+      createFields.idLabels = input.idLabels.join(",");
+
+    const createRes = await ctx.fetch(`${TRELLO_BASE}/cards`, {
+      method: "POST",
+      headers: trelloFormHeaders,
+      body: trelloFormBody(createFields),
+    });
+    if (!createRes.ok) await trelloError("createCard", createRes);
+    let card = (await createRes.json()) as z.infer<typeof cardOutputSchema>;
+    const cardId = card.id;
+
+    if (input.idMembers?.length) {
+      for (const memberId of input.idMembers) {
+        const memberRes = await ctx.fetch(
+          `${TRELLO_BASE}/cards/${cardId}/idMembers`,
+          {
+            method: "POST",
+            headers: trelloFormHeaders,
+            body: trelloFormBody({ value: memberId }),
+          },
+        );
+        if (!memberRes.ok) await trelloError("createCard", memberRes);
+      }
+    }
+
+    const attachUrl = input.attachmentUrl ?? input.attachmentFileUrl;
+    if (attachUrl) {
+      if (input.attachmentFileUrl) {
+        const fileRes = await ctx.fetch(input.attachmentFileUrl);
+        if (!fileRes.ok) await trelloError("createCard", fileRes);
+        const buffer = await fileRes.arrayBuffer();
+        const form = new FormData();
+        form.append("file", new Blob([buffer]), "attachment");
+        form.append("name", "attachment");
+        const uploadRes = await ctx.fetch(
+          `${TRELLO_BASE}/cards/${cardId}/attachments`,
+          { method: "POST", body: form },
+        );
+        if (!uploadRes.ok) await trelloError("createCard", uploadRes);
+      } else {
+        const urlRes = await ctx.fetch(
+          `${TRELLO_BASE}/cards/${cardId}/attachments`,
+          {
+            method: "POST",
+            headers: trelloFormHeaders,
+            body: trelloFormBody({ url: attachUrl, name: attachUrl }),
+          },
+        );
+        if (!urlRes.ok) await trelloError("createCard", urlRes);
+      }
+    }
+
+    if (input.checklistName) {
+      const checklistRes = await ctx.fetch(`${TRELLO_BASE}/checklists`, {
+        method: "POST",
+        headers: trelloFormHeaders,
+        body: trelloFormBody({
+          idCard: cardId,
+          name: input.checklistName,
+        }),
+      });
+      if (!checklistRes.ok) await trelloError("createCard", checklistRes);
+      const checklist = (await checklistRes.json()) as { id: string };
+      if (input.checklistItems?.length) {
+        for (const itemName of input.checklistItems) {
+          const itemRes = await ctx.fetch(
+            `${TRELLO_BASE}/checklists/${checklist.id}/checkItems`,
+            {
+              method: "POST",
+              headers: trelloFormHeaders,
+              body: trelloFormBody({ name: itemName }),
+            },
+          );
+          if (!itemRes.ok) await trelloError("createCard", itemRes);
+        }
+      }
+    }
+
+    if (
+      input.customFieldValues &&
+      Object.keys(input.customFieldValues).length
+    ) {
+      const boardId = card.idBoard;
+      const fieldsRes = await ctx.fetch(
+        `${TRELLO_BASE}/boards/${boardId}/customFields`,
+      );
+      if (!fieldsRes.ok) await trelloError("createCard", fieldsRes);
+      const fields = (await fieldsRes.json()) as Array<{
+        id: string;
+        name: string;
+        type: string;
+      }>;
+      const byName = new Map(fields.map((f) => [f.name, f]));
+      for (const [fieldName, rawValue] of Object.entries(
+        input.customFieldValues,
+      )) {
+        const field = byName.get(fieldName);
+        if (!field) {
+          throw new Error(
+            `Trello createCard: unknown custom field "${fieldName}". Resolve via listCustomFields.`,
+          );
+        }
+        let itemValue: Record<string, unknown> = {};
+        switch (field.type) {
+          case "checkbox":
+            itemValue = { checked: Boolean(rawValue) ? "true" : "false" };
+            break;
+          case "date":
+            itemValue = { date: String(rawValue) };
+            break;
+          case "number":
+            itemValue = { number: String(rawValue) };
+            break;
+          case "list": {
+            itemValue = { idValue: String(rawValue) };
+            break;
+          }
+          default:
+            itemValue = { text: String(rawValue) };
+        }
+        const cfRes = await ctx.fetch(
+          `${TRELLO_BASE}/cards/${cardId}/customField/${field.id}/item`,
+          {
+            method: "PUT",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ value: itemValue }),
+          },
+        );
+        if (!cfRes.ok) await trelloError("createCard", cfRes);
+      }
+    }
+
+    const refreshRes = await ctx.fetch(`${TRELLO_BASE}/cards/${cardId}`);
+    if (refreshRes.ok) {
+      card = (await refreshRes.json()) as z.infer<typeof cardOutputSchema>;
+    }
+    return card;
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/createChecklist.ts

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+
+const inputSchema = z.object({ idCard: z.string(), name: z.string() }).strict();
+const outputSchema = z.object({
+  id: z
+    .string()
+    .regex(new RegExp("^[0-9a-fA-F]{24}$"))
+    .describe("Trello object id (24 hex chars)."),
+  name: z.string(),
+  idCard: z.string().nullable().optional(),
+});
+
+const definition = defineTool({
+  name: "createChecklist",
+  title: "Create Checklist",
+  description: "Create a checklist on a card.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/checklists`;
+    const body: Record<string, unknown> = {};
+    if (input.idCard !== undefined) body["idCard"] = input.idCard;
+    if (input.name !== undefined) body["name"] = input.name;
+    const res = await ctx.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello createChecklist ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/createComment.ts

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+
+const inputSchema = z
+  .object({
+    id: z.string().describe("24-char hex card id."),
+    text: z
+      .string()
+      .describe(
+        "Comment body (Trello Markdown; @member mentions use @username).",
+      ),
+  })
+  .strict();
+const outputSchema = z.object({
+  id: z
+    .string()
+    .regex(new RegExp("^[0-9a-fA-F]{24}$"))
+    .describe("Trello object id (24 hex chars)."),
+  type: z.string(),
+  date: z.string().datetime({ offset: true }),
+  data: z
+    .object({
+      text: z.string().nullable().optional(),
+      card: z
+        .object({
+          id: z.string().nullable().optional(),
+          name: z.string().nullable().optional(),
+        })
+        .nullable()
+        .optional(),
+    })
+    .nullable()
+    .optional(),
+});
+
+const definition = defineTool({
+  name: "createComment",
+  title: "Create Comment",
+  description: "Add a comment to a card.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/cards/${encodeURIComponent(input.id)}/actions/comments`;
+    const body: Record<string, unknown> = {};
+    if (input.text !== undefined) body["text"] = input.text;
+    const res = await ctx.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello createComment ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/createLabel.ts

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+
+const inputSchema = z
+  .object({
+    name: z.string().optional(),
+    color: z
+      .enum([
+        "yellow",
+        "purple",
+        "blue",
+        "red",
+        "green",
+        "orange",
+        "black",
+        "sky",
+        "pink",
+        "lime",
+      ])
+      .optional(),
+    idBoard: z.string(),
+  })
+  .strict();
+const outputSchema = z.object({
+  id: z
+    .string()
+    .regex(new RegExp("^[0-9a-fA-F]{24}$"))
+    .describe("Trello object id (24 hex chars)."),
+  idBoard: z.string(),
+  name: z.string().nullable().optional(),
+  color: z.string().nullable().optional(),
+});
+
+const definition = defineTool({
+  name: "createLabel",
+  title: "Create Label",
+  description:
+    "Create a label on a board (or add a named label to a card when idCard set).",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/labels`;
+    const body: Record<string, unknown> = {};
+    if (input.name !== undefined) body["name"] = input.name;
+    if (input.color !== undefined) body["color"] = input.color;
+    if (input.idBoard !== undefined) body["idBoard"] = input.idBoard;
+    const res = await ctx.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello createLabel ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/createList.ts

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+
+const inputSchema = z
+  .object({
+    name: z.string(),
+    idBoard: z.string().describe("Board id."),
+    pos: z
+      .any()
+      .superRefine((x, ctx) => {
+        const schemas = [z.enum(["top", "bottom"]), z.number()];
+        const { errors, failed } = schemas.reduce<{
+          errors: z.core.$ZodIssue[];
+          failed: number;
+        }>(
+          ({ errors, failed }, schema) =>
+            ((result) =>
+              result.error
+                ? {
+                    errors: [...errors, ...result.error.issues],
+                    failed: failed + 1,
+                  }
+                : { errors, failed })(schema.safeParse(x)),
+          { errors: [], failed: 0 },
+        );
+        const passed = schemas.length - failed;
+        if (passed !== 1) {
+          ctx.addIssue(
+            errors.length
+              ? {
+                  path: [],
+                  code: "invalid_union",
+                  errors: [errors],
+                  message:
+                    "Invalid input: Should pass single schema. Passed " +
+                    passed,
+                }
+              : {
+                  path: [],
+                  code: "custom",
+                  errors: [errors],
+                  message:
+                    "Invalid input: Should pass single schema. Passed " +
+                    passed,
+                },
+          );
+        }
+      })
+      .optional(),
+  })
+  .strict();
+const outputSchema = z.object({
+  id: z
+    .string()
+    .regex(new RegExp("^[0-9a-fA-F]{24}$"))
+    .describe("Trello object id (24 hex chars)."),
+  name: z.string(),
+  closed: z.boolean().nullable().optional(),
+  idBoard: z.string(),
+  pos: z.number().nullable().optional(),
+});
+
+const definition = defineTool({
+  name: "createList",
+  title: "Create List",
+  description: "Create a list on a board.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/lists`;
+    const body: Record<string, unknown> = {};
+    if (input.name !== undefined) body["name"] = input.name;
+    if (input.idBoard !== undefined) body["idBoard"] = input.idBoard;
+    if (input.pos !== undefined) body["pos"] = input.pos;
+    const res = await ctx.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello createList ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/deleteChecklist.ts

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+
+const inputSchema = z.object({ id: z.string() }).strict();
+const outputSchema = z.object({ status: z.number() });
+
+const definition = defineTool({
+  name: "deleteChecklist",
+  title: "Delete Checklist",
+  description: "Delete a checklist.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/checklists/${encodeURIComponent(input.id)}`;
+    const res = await ctx.fetch(url, {
+      method: "DELETE",
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello deleteChecklist ${res.status}: ${errBody}`);
+    }
+    return { status: res.status };
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/findBoard.ts

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+import { TRELLO_BASE, trelloError } from "../lib/trello.ts";
+
+const inputSchema = z
+  .object({ query: z.string(), organizationId: z.string().optional() })
+  .strict();
+const itemSchema = z.array(
+  z.object({
+    id: z
+      .string()
+      .regex(new RegExp("^[0-9a-fA-F]{24}$"))
+      .describe("Trello object id (24 hex chars)."),
+    name: z.string(),
+    desc: z.string().nullable().optional(),
+    closed: z.boolean().nullable().optional(),
+    idOrganization: z.string().nullable().optional(),
+    url: z.string().nullable().optional(),
+    shortUrl: z.string().nullable().optional(),
+    dateLastActivity: z
+      .string()
+      .datetime({ offset: true })
+      .nullable()
+      .optional(),
+  }),
+);
+const outputSchema = z.object({ items: itemSchema });
+
+const definition = defineTool({
+  name: "findBoard",
+  title: "Find Board",
+  description: "Find boards by name via GET /search with modelTypes=boards.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = new URL(`${TRELLO_BASE}/search`);
+    url.searchParams.set("query", input.query);
+    url.searchParams.set("modelTypes", "boards");
+    url.searchParams.set("boardsLimit", "50");
+    if (input.organizationId !== undefined) {
+      url.searchParams.set("idOrganizations", input.organizationId);
+    }
+    const res = await ctx.fetch(url.toString(), { method: "GET" });
+    if (!res.ok) await trelloError("findBoard", res);
+    const data = (await res.json()) as { boards?: unknown[] };
+    return { items: data.boards ?? [] };
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });