@zapier/trello-connector 0.0.0 → 0.1.0

package/scripts/moveCard.ts

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+// Authored by the implementation agent: thin intent wrapper over PUT /cards/{id} (idList/idBoard).
+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 inputSchema = z
+  .object({
+    id: z.string().describe("24-char hex card id to move."),
+    idList: z
+      .string()
+      .describe("Destination list id. Resolve via listLists or findList."),
+    idBoard: z
+      .string()
+      .describe("Destination board id when moving across boards.")
+      .optional(),
+  })
+  .strict();
+
+const outputSchema = z.object({
+  id: z.string().regex(TRELLO_ID_REGEX),
+  name: z.string(),
+  closed: z.boolean().nullable().optional(),
+  idBoard: z.string(),
+  idList: z.string(),
+  url: z.string(),
+  shortUrl: z.string().nullable().optional(),
+});
+
+const definition = defineTool({
+  name: "moveCard",
+  title: "Move Card",
+  description:
+    "Move a card to another list (and optionally another board). Resolve list ids via listLists or findList before calling.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `${TRELLO_BASE}/cards/${encodeURIComponent(input.id)}`;
+    const body: Record<string, string> = { idList: input.idList };
+    if (input.idBoard !== undefined) body.idBoard = input.idBoard;
+    const res = await ctx.fetch(url, {
+      method: "PUT",
+      headers: trelloFormHeaders,
+      body: trelloFormBody(body),
+    });
+    if (!res.ok) await trelloError("moveCard", res);
+    return res.json() as Promise<z.infer<typeof outputSchema>>;
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/removeCardLabel.ts

@@ -0,0 +1,43 @@
+#!/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."),
+    idLabel: z.string(),
+  })
+  .strict();
+const outputSchema = z.object({ status: z.number() });
+
+const definition = defineTool({
+  name: "removeCardLabel",
+  title: "Remove Card Label",
+  description: "Remove a label from a card.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/cards/${encodeURIComponent(input.id)}/idLabels/${encodeURIComponent(input.idLabel)}`;
+    const res = await ctx.fetch(url, {
+      method: "DELETE",
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello removeCardLabel ${res.status}: ${errBody}`);
+    }
+    return { status: res.status };
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/searchCards.ts

@@ -0,0 +1,153 @@
+#!/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";
+
+function buildSearchQuery(input: {
+  query?: string;
+  keyword?: string;
+  listName?: string;
+  member?: string;
+  label?: string;
+  dueFilter?: string;
+}): string {
+  if (input.query !== undefined) return input.query;
+  const parts: string[] = [];
+  if (input.keyword !== undefined) parts.push(input.keyword);
+  if (input.listName !== undefined) parts.push(`list:${input.listName}`);
+  if (input.member !== undefined) {
+    parts.push(
+      input.member.startsWith("@") ? input.member : `@${input.member}`,
+    );
+  }
+  if (input.label !== undefined) parts.push(`label:${input.label}`);
+  if (input.dueFilter !== undefined) parts.push(`due:${input.dueFilter}`);
+  if (parts.length === 0) {
+    throw new Error("Trello searchCards: provide query or keyword.");
+  }
+  return parts.join(" ");
+}
+
+const inputSchema = z
+  .object({
+    query: z
+      .string()
+      .describe(
+        "Raw Trello query string (e.g. board:MyBoard @me due:week). Mutually exclusive with keyword-based structured search.",
+      )
+      .optional(),
+    keyword: z
+      .string()
+      .describe("Search card name/description when not using raw query.")
+      .optional(),
+    boardId: z.string().describe("Limit to this board id.").optional(),
+    listName: z.string().optional(),
+    member: z
+      .string()
+      .describe("Member filter; use @me for current user.")
+      .optional(),
+    label: z.string().optional(),
+    dueFilter: z
+      .enum(["day", "week", "month", "overdue", "complete", "incomplete"])
+      .optional(),
+    organizationId: z.string().optional(),
+    cardsLimit: z
+      .number()
+      .int()
+      .gte(1)
+      .lte(1000)
+      .describe(
+        "Defaults to 20 when omitted; pass a value when you need a specific number of results.",
+      )
+      .optional(),
+    partial: z.boolean().default(true),
+  })
+  .strict();
+const outputSchema = z.object({
+  items: 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(),
+        idBoard: z.string(),
+        idList: z.string(),
+        idShort: z.number().int().nullable().optional(),
+        shortLink: z.string().nullable().optional(),
+        shortUrl: z.string().nullable().optional(),
+        url: z.string().nullable().optional(),
+        due: z
+          .union([z.string().datetime({ offset: true }), z.null()])
+          .optional(),
+        dueComplete: z.boolean().nullable().optional(),
+        dateLastActivity: z
+          .string()
+          .datetime({ offset: true })
+          .nullable()
+          .optional(),
+        idLabels: z.array(z.string()).nullable().optional(),
+        idMembers: z.array(z.string()).nullable().optional(),
+        labels: z
+          .array(
+            z.object({
+              id: z.string(),
+              name: z.string().nullable().optional(),
+              color: z.string().nullable().optional(),
+            }),
+          )
+          .nullable()
+          .optional(),
+        pos: z.number().nullable().optional(),
+        customFields: z.record(z.string(), z.json()).nullable().optional(),
+      }),
+    )
+    .nullable()
+    .optional(),
+  has_more: z.boolean().nullable().optional(),
+});
+
+const definition = defineTool({
+  name: "searchCards",
+  title: "Search Cards",
+  description: "Search for cards using Trello query DSL or structured filters.",
+  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", buildSearchQuery(input));
+    url.searchParams.set("modelTypes", "cards");
+    if (input.boardId !== undefined) {
+      url.searchParams.set("idBoards", input.boardId);
+    }
+    if (input.organizationId !== undefined) {
+      url.searchParams.set("idOrganizations", input.organizationId);
+    }
+    const limit = input.cardsLimit ?? 20;
+    url.searchParams.set("cards_limit", String(limit));
+    if (input.partial !== undefined) {
+      url.searchParams.set("partial", String(input.partial));
+    }
+    const res = await ctx.fetch(url.toString(), { method: "GET" });
+    if (!res.ok) await trelloError("searchCards", res);
+    const data = (await res.json()) as { cards?: unknown[] };
+    const items = Array.isArray(data.cards) ? data.cards : [];
+    return { items, has_more: items.length >= limit };
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/updateCard.ts

@@ -0,0 +1,184 @@
+#!/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."),
+    name: z.string().optional(),
+    desc: z
+      .string()
+      .describe(
+        "Card description (Trello Markdown). Append vs overwrite controlled by descOverwrite.",
+      )
+      .optional(),
+    descOverwrite: z
+      .boolean()
+      .describe("When false, append desc to existing; when true, replace.")
+      .optional(),
+    due: z
+      .string()
+      .datetime({ offset: true })
+      .describe("Due datetime (ISO 8601). Pass null string to clear.")
+      .optional(),
+    start: z
+      .string()
+      .datetime({ offset: true })
+      .describe("Start datetime. Pass null string to clear.")
+      .optional(),
+    dueComplete: z.boolean().optional(),
+    closed: z
+      .boolean()
+      .describe("Set true to archive the card (archiveCard tool behavior).")
+      .optional(),
+    idList: z
+      .string()
+      .describe("Move card to this list id (moveCard tool behavior).")
+      .optional(),
+    idBoard: z
+      .string()
+      .describe("Destination board when moving across boards.")
+      .optional(),
+    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(),
+    address: z.string().optional(),
+    locationName: z.string().optional(),
+    coordinates: z
+      .string()
+      .describe("latitude,longitude e.g. 40.712776,-74.005974")
+      .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(),
+  desc: z.string().nullable().optional(),
+  closed: z.boolean().nullable().optional(),
+  idBoard: z.string(),
+  idList: z.string(),
+  idShort: z.number().int().nullable().optional(),
+  shortLink: z.string().nullable().optional(),
+  shortUrl: z.string().nullable().optional(),
+  url: z.string().nullable().optional(),
+  due: z.union([z.string().datetime({ offset: true }), z.null()]).optional(),
+  dueComplete: z.boolean().nullable().optional(),
+  dateLastActivity: z.string().datetime({ offset: true }).nullable().optional(),
+  idLabels: z.array(z.string()).nullable().optional(),
+  idMembers: z.array(z.string()).nullable().optional(),
+  labels: z
+    .array(
+      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(),
+      }),
+    )
+    .nullable()
+    .optional(),
+  pos: z.number().nullable().optional(),
+  customFields: z
+    .record(z.string(), z.any())
+    .nullable()
+    .describe("Custom field values keyed by field name when requested.")
+    .optional(),
+});
+
+const definition = defineTool({
+  name: "updateCard",
+  title: "Update Card",
+  description:
+    "Update card fields (name, description, due, cover, list, archive). Custom fields updated separately in run() polish.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/cards/${encodeURIComponent(input.id)}`;
+    const body: Record<string, unknown> = {};
+    if (input.name !== undefined) body["name"] = input.name;
+    if (input.desc !== undefined) body["desc"] = input.desc;
+    if (input.descOverwrite !== undefined)
+      body["descOverwrite"] = input.descOverwrite;
+    if (input.due !== undefined) body["due"] = input.due;
+    if (input.start !== undefined) body["start"] = input.start;
+    if (input.dueComplete !== undefined)
+      body["dueComplete"] = input.dueComplete;
+    if (input.closed !== undefined) body["closed"] = input.closed;
+    if (input.idList !== undefined) body["idList"] = input.idList;
+    if (input.idBoard !== undefined) body["idBoard"] = input.idBoard;
+    if (input.pos !== undefined) body["pos"] = input.pos;
+    if (input.address !== undefined) body["address"] = input.address;
+    if (input.locationName !== undefined)
+      body["locationName"] = input.locationName;
+    if (input.coordinates !== undefined)
+      body["coordinates"] = input.coordinates;
+    const res = await ctx.fetch(url, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello updateCard ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/tsup.config.ts

@@ -0,0 +1,63 @@
+/**
+ * tsup build config for connectors.
+ *
+ * Compiles index.ts (library entry, bundled) and cli.ts (CLI, bundled but
+ * with the connector's index module kept external).
+ *
+ * The cli.ts entry externalises ./index.ts → ./index.js via an esbuild plugin
+ * so that dist/cli.js imports the pre-built dist/index.js as a separate module
+ * rather than inlining scripts. Without this, each script's top-level
+ * `await handleIfScriptMain(import.meta, …)` ends up inside the single-file
+ * bundle; in Node 22.18+ import.meta.main is true for the bundle entry,
+ * causing every script to execute when the dispatch CLI starts instead of
+ * routing via runDispatchCli.
+ *
+ * Managed by @zapier/connectors-dev — do not edit; synced byte-for-byte
+ * across every connector.
+ */
+import { defineConfig } from "tsup";
+
+export default defineConfig([
+  {
+    entry: ["index.ts"],
+    format: ["esm"],
+    dts: false,
+    clean: true,
+    target: "es2022",
+    external: [
+      "@modelcontextprotocol/sdk",
+      "@zapier/zapier-sdk",
+      "zod",
+      "@zapier/connectors-sdk",
+    ],
+  },
+  {
+    entry: ["cli.ts"],
+    format: ["esm"],
+    dts: false,
+    clean: false,
+    target: "es2022",
+    external: [
+      "@modelcontextprotocol/sdk",
+      "@zapier/zapier-sdk",
+      "zod",
+      "@zapier/connectors-sdk",
+    ],
+    esbuildPlugins: [
+      {
+        name: "externalize-connector-index",
+        setup(build) {
+          // Resolve ./index.ts to the pre-built ./index.js and mark it external
+          // so scripts are not inlined into dist/cli.js. When dist/index.js is
+          // imported (not the entry), import.meta.main is false inside it and
+          // handleIfScriptMain's existing !meta.main guard suppresses per-script
+          // execution — no SDK changes required.
+          build.onResolve({ filter: /^\.\/index(\.ts)?$/ }, () => ({
+            path: "./index.js",
+            external: true,
+          }));
+        },
+      },
+    ],
+  },
+]);