@divyacon/piece-trello 0.0.0-stage → 0.1.0

package/src/index.ts

@@ -0,0 +1,153 @@
+import {
+  HttpMethod,
+  HttpRequest,
+  createCustomApiCallAction,
+  httpClient,
+} from '@agnocon/pieces-common';
+import { PieceAuth, createPiece } from '@agnocon/pieces-framework';
+import { PieceCategory } from '@agnocon/pieces-framework';
+import { createCard } from './lib/actions/card/create-card';
+import { getCard } from './lib/actions/card/get-card';
+import { updateCard } from './lib/actions/card/update-card';
+import { deleteCard } from './lib/actions/card/delete-card';
+import { getCardAttachments } from './lib/actions/card-attachment/get-card-attachments';
+import { addCardAttachment } from './lib/actions/card-attachment/add-card-attachment';
+import { getCardAttachment } from './lib/actions/card-attachment/get-card-attachment';
+import { deleteCardAttachment } from './lib/actions/card-attachment/delete-card-attachment';
+// audience:'ai' agent atomics (twins reuse existing run() logic with agent-shaped props)
+import { createCardAi } from './lib/actions/ai/create-card-ai';
+import { getCardAi } from './lib/actions/ai/get-card-ai';
+import { updateCardAi } from './lib/actions/ai/update-card-ai';
+import { deleteCardAi } from './lib/actions/ai/delete-card-ai';
+import { listCardAttachmentsAi } from './lib/actions/ai/list-card-attachments-ai';
+import { searchCards } from './lib/actions/ai/search-cards';
+import { searchMembers } from './lib/actions/ai/search-members';
+import { listCardsInList } from './lib/actions/ai/list-cards-in-list';
+import { listCardsInBoard } from './lib/actions/ai/list-cards-in-board';
+import { addCommentToCard } from './lib/actions/ai/add-comment-to-card';
+import { listCardComments } from './lib/actions/ai/list-card-comments';
+import { updateComment } from './lib/actions/ai/update-comment';
+import { deleteComment } from './lib/actions/ai/delete-comment';
+import { addMemberToCard } from './lib/actions/ai/add-member-to-card';
+import { removeMemberFromCard } from './lib/actions/ai/remove-member-from-card';
+import { listCardMembers } from './lib/actions/ai/list-card-members';
+import { createBoardLabel } from './lib/actions/ai/create-board-label';
+import { addLabelToCard } from './lib/actions/ai/add-label-to-card';
+import { removeLabelFromCard } from './lib/actions/ai/remove-label-from-card';
+import { listBoardLabels } from './lib/actions/ai/list-board-labels';
+import { updateLabel } from './lib/actions/ai/update-label';
+import { moveCard } from './lib/actions/ai/move-card';
+import { archiveCard } from './lib/actions/ai/archive-card';
+import { createList } from './lib/actions/ai/create-list';
+import { listLists } from './lib/actions/ai/list-lists';
+import { getList } from './lib/actions/ai/get-list';
+import { renameList } from './lib/actions/ai/rename-list';
+import { archiveList } from './lib/actions/ai/archive-list';
+import { moveAllCardsInList } from './lib/actions/ai/move-all-cards-in-list';
+import { archiveAllCardsInList } from './lib/actions/ai/archive-all-cards-in-list';
+import { createBoard } from './lib/actions/ai/create-board';
+import { getBoard } from './lib/actions/ai/get-board';
+import { listBoards } from './lib/actions/ai/list-boards';
+import { updateBoard } from './lib/actions/ai/update-board';
+import { archiveBoard } from './lib/actions/ai/archive-board';
+import { listBoardMembers } from './lib/actions/ai/list-board-members';
+import { addChecklistToCard } from './lib/actions/ai/add-checklist-to-card';
+import { listCardChecklists } from './lib/actions/ai/list-card-checklists';
+import { deleteChecklist } from './lib/actions/ai/delete-checklist';
+import { setChecklistItemState } from './lib/actions/ai/set-checklist-item-state';
+import { deleteChecklistItem } from './lib/actions/ai/delete-checklist-item';
+import { addChecklistItem } from './lib/actions/ai/add-checklist-item';
+import { getMyMember } from './lib/actions/ai/get-my-member';
+import { getMember } from './lib/actions/ai/get-member';
+import { listOrganizationBoards } from './lib/actions/ai/list-organization-boards';
+import { addReactionToComment } from './lib/actions/ai/add-reaction-to-comment';
+import { cardMovedTrigger } from './lib/triggers/cardMoved';
+import { newCardTrigger } from './lib/triggers/newCard';
+import { deadlineTrigger } from './lib/triggers/deadline';
+
+const markdownProperty = `
+To obtain your API key and token, follow these steps:
+
+1. Go to https://trello.com/power-ups/admin.
+2. Click **New** to create a new power-up.
+3. Enter power-up information, and click **Create**.
+4. From the API Key page, click **Generate a new API key**.
+5. Copy **API Key** and enter it into the Trello API Key connection.
+6. On the right side of the page, find the text *"you can manually generate a Token"* and click the **Token** link.**Do not use the Secret field below the API key**.
+7. Authorize the app and copy the generated token.
+8. Paste the token into the Trello Token field.
+`;
+export const trelloAuth = PieceAuth.BasicAuth({
+  description: markdownProperty,
+  required: true,
+  username: {
+    displayName: 'API Key',
+    description: 'Trello API Key',
+  },
+  password: {
+    displayName: 'Token',
+    description: 'Trello Token',
+  },
+  validate: async ({ auth }) => {
+    const { username, password } = auth;
+    if (!username || !password) {
+      return {
+        valid: false,
+        error: 'Empty API Key or Token',
+      };
+    }
+    try {
+      const request: HttpRequest = {
+        method: HttpMethod.GET,
+        url:
+          `https://api.trello.com/1/members/me/boards` +
+          `?key=` +
+          username +
+          `&token=` +
+          password,
+      };
+      await httpClient.sendRequest(request);
+      return {
+        valid: true,
+      };
+    } catch (e) {
+      return {
+        valid: false,
+        error: 'Invalid API Key or Token',
+      };
+    }
+  },
+});
+
+export const trello = createPiece({
+  displayName: 'Trello',
+  description: 'Project management tool for teams',
+  minimumSupportedRelease: '0.86.4',
+  logoUrl: 'https://cdn.activepieces.com/pieces/trello.png',
+  authors: ["Salem-Alaa", "kishanprmr", "MoShizzle", "khaledmashaly", "abuaboud", "AshotZaqoyan"],
+  categories: [PieceCategory.PRODUCTIVITY],
+  auth: trelloAuth,
+  actions: [createCard, getCard, updateCard, deleteCard, getCardAttachments, addCardAttachment, getCardAttachment, deleteCardAttachment,
+    // audience:'ai' agent atomics
+    createCardAi, getCardAi, updateCardAi, deleteCardAi, listCardAttachmentsAi, searchCards, searchMembers, listCardsInList, listCardsInBoard,
+    addCommentToCard, listCardComments, updateComment, deleteComment,
+    addMemberToCard, removeMemberFromCard, listCardMembers,
+    createBoardLabel, addLabelToCard, removeLabelFromCard, listBoardLabels, updateLabel,
+    moveCard, archiveCard,
+    createList, listLists, getList, renameList, archiveList, moveAllCardsInList, archiveAllCardsInList,
+    createBoard, getBoard, listBoards, updateBoard, archiveBoard, listBoardMembers,
+    addChecklistToCard, listCardChecklists, deleteChecklist, setChecklistItemState, deleteChecklistItem, addChecklistItem,
+    getMyMember, getMember, listOrganizationBoards, addReactionToComment, createCustomApiCallAction({
+      auth: trelloAuth,
+      baseUrl: () => 'https://api.trello.com/1',
+      authLocation: 'queryParams',
+      authMapping: async (auth) => {
+        return {
+          key: auth.username,
+          token: auth.password
+        }
+      }
+    })
+  ],
+  triggers: [cardMovedTrigger, newCardTrigger, deadlineTrigger],
+});

package/src/lib/actions/ai/add-checklist-item.ts

@@ -0,0 +1,67 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  httpClient,
+  HttpRequest,
+  HttpMethod,
+  QueryParams,
+} from '@agnocon/pieces-common';
+import { trelloCommon } from '../../common';
+import { trelloAuth } from '../../..';
+import { withAuthParams, rethrowTrelloError } from './ai-common';
+import { addChecklistItemActionOutputSchema } from '../../output-schemas';
+
+
+export const addChecklistItem = createAction({
+  auth: trelloAuth,
+  name: 'add_checklist_item',
+  displayName: 'Add Checklist Item (Agent)',
+  description: 'Add an item to a Trello checklist.',
+  audience: 'ai',
+  outputSchema: addChecklistItemActionOutputSchema,
+  aiMetadata: {
+    description:
+      'Adds a check item to an existing Trello checklist. Obtain checklist_id (idChecklist) from List Card Checklists (or the output of Add Checklist To Card). Each call adds a distinct item, so it is not idempotent.',
+    idempotent: false,
+  },
+  props: {
+    checklist_id: Property.ShortText({
+      displayName: 'Checklist ID',
+      description:
+        'The checklist id (idChecklist). Obtain it from List Card Checklists or Add Checklist To Card.',
+      required: true,
+    }),
+    name: Property.ShortText({
+      displayName: 'Item Name',
+      required: true,
+    }),
+    checked: Property.Checkbox({
+      displayName: 'Checked',
+      description: 'Create the item already marked complete.',
+      required: false,
+    }),
+  },
+
+  async run(context) {
+    const params: QueryParams = {
+      name: context.propsValue['name'],
+    };
+    if (context.propsValue['checked'] !== undefined) {
+      params['checked'] = context.propsValue['checked'] ? 'true' : 'false';
+    }
+    try {
+      const request: HttpRequest = {
+        method: HttpMethod.POST,
+        url: `${trelloCommon.baseUrl}checklists/${context.propsValue['checklist_id']}/checkItems`,
+        headers: { Accept: 'application/json' },
+        queryParams: withAuthParams(context.auth, params),
+      };
+      const response = await httpClient.sendRequest(request);
+      return response.body;
+    } catch (error: any) {
+      rethrowTrelloError(
+        error,
+        'Checklist not found. Verify the checklist_id (resolve it via List Card Checklists).'
+      );
+    }
+  },
+});

package/src/lib/actions/ai/add-checklist-to-card.ts

@@ -0,0 +1,58 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  httpClient,
+  HttpRequest,
+  HttpMethod,
+  QueryParams,
+} from '@agnocon/pieces-common';
+import { trelloCommon } from '../../common';
+import { trelloAuth } from '../../..';
+import { withAuthParams, rethrowTrelloError } from './ai-common';
+import { addChecklistToCardActionOutputSchema } from '../../output-schemas';
+
+export const addChecklistToCard = createAction({
+  auth: trelloAuth,
+  name: 'add_checklist_to_card',
+  displayName: 'Add Checklist To Card (Agent)',
+  description: 'Create a checklist on a Trello card.',
+  audience: 'ai',
+  outputSchema: addChecklistToCardActionOutputSchema,
+  aiMetadata: {
+    description:
+      'Creates a checklist on a Trello card and returns its idChecklist, which you then pass to Add Checklist Item and Set Checklist Item State. Obtain card_id from Search Cards. Each call creates a distinct checklist, so it is not idempotent.',
+    idempotent: false,
+  },
+  props: {
+    card_id: Property.ShortText({
+      displayName: 'Card ID',
+      description: 'The ID of the card. Obtain it from Search Cards.',
+      required: true,
+    }),
+    name: Property.ShortText({
+      displayName: 'Checklist Name',
+      required: false,
+    }),
+  },
+
+  async run(context) {
+    const params: QueryParams = {};
+    if (context.propsValue['name']) {
+      params['name'] = context.propsValue['name'] as string;
+    }
+    try {
+      const request: HttpRequest = {
+        method: HttpMethod.POST,
+        url: `${trelloCommon.baseUrl}cards/${context.propsValue['card_id']}/checklists`,
+        headers: { Accept: 'application/json' },
+        queryParams: withAuthParams(context.auth, params),
+      };
+      const response = await httpClient.sendRequest(request);
+      return response.body;
+    } catch (error: any) {
+      rethrowTrelloError(
+        error,
+        'Card not found. Verify the card_id (resolve it via Search Cards).'
+      );
+    }
+  },
+});

package/src/lib/actions/ai/add-comment-to-card.ts

@@ -0,0 +1,55 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  httpClient,
+  HttpRequest,
+  HttpMethod,
+} from '@agnocon/pieces-common';
+import { trelloCommon } from '../../common';
+import { trelloAuth } from '../../..';
+import { withAuthParams, rethrowTrelloError } from './ai-common';
+import { addCommentToCardActionOutputSchema } from '../../output-schemas';
+
+export const addCommentToCard = createAction({
+  auth: trelloAuth,
+  name: 'add_comment_to_card',
+  displayName: 'Add Comment To Card (Agent)',
+  description: 'Add a comment to a Trello card.',
+  audience: 'ai',
+  outputSchema: addCommentToCardActionOutputSchema,
+  aiMetadata: {
+    description:
+      'Posts a comment on a Trello card identified by card_id. This is the primary way for an agent to report status or notes on a card. Obtain card_id from Search Cards. Each call adds a new comment, so it is not idempotent.',
+    idempotent: false,
+  },
+  props: {
+    card_id: Property.ShortText({
+      displayName: 'Card ID',
+      description: 'The ID of the card to comment on. Obtain it from Search Cards.',
+      required: true,
+    }),
+    text: Property.LongText({
+      displayName: 'Comment Text',
+      required: true,
+    }),
+  },
+
+  async run(context) {
+    try {
+      const request: HttpRequest = {
+        method: HttpMethod.POST,
+        url: `${trelloCommon.baseUrl}cards/${context.propsValue['card_id']}/actions/comments`,
+        headers: { Accept: 'application/json' },
+        queryParams: withAuthParams(context.auth, {
+          text: context.propsValue['text'],
+        }),
+      };
+      const response = await httpClient.sendRequest(request);
+      return response.body;
+    } catch (error: any) {
+      rethrowTrelloError(
+        error,
+        'Card not found. Verify the card_id (resolve it via Search Cards).'
+      );
+    }
+  },
+});

package/src/lib/actions/ai/add-label-to-card.ts

@@ -0,0 +1,57 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  httpClient,
+  HttpRequest,
+  HttpMethod,
+} from '@agnocon/pieces-common';
+import { trelloCommon } from '../../common';
+import { trelloAuth } from '../../..';
+import { withAuthParams, rethrowTrelloError } from './ai-common';
+import { addLabelToCardActionOutputSchema } from '../../output-schemas';
+
+export const addLabelToCard = createAction({
+  auth: trelloAuth,
+  name: 'add_label_to_card',
+  displayName: 'Add Label To Card (Agent)',
+  description: 'Attach an existing label to a Trello card.',
+  audience: 'ai',
+  outputSchema: addLabelToCardActionOutputSchema,
+  aiMetadata: {
+    description:
+      'Attaches an existing board label to a Trello card. Obtain card_id from Search Cards and label_id from List Board Labels (or Create Board Label). Re-attaching an already-present label converges to the same label set, so it is idempotent.',
+    idempotent: true,
+  },
+  props: {
+    card_id: Property.ShortText({
+      displayName: 'Card ID',
+      description: 'The ID of the card. Obtain it from Search Cards.',
+      required: true,
+    }),
+    label_id: Property.ShortText({
+      displayName: 'Label ID',
+      description:
+        'The label id to attach. Obtain it from List Board Labels or Create Board Label.',
+      required: true,
+    }),
+  },
+
+  async run(context) {
+    try {
+      const request: HttpRequest = {
+        method: HttpMethod.POST,
+        url: `${trelloCommon.baseUrl}cards/${context.propsValue['card_id']}/idLabels`,
+        headers: { Accept: 'application/json' },
+        queryParams: withAuthParams(context.auth, {
+          value: context.propsValue['label_id'],
+        }),
+      };
+      const response = await httpClient.sendRequest(request);
+      return response.body;
+    } catch (error: any) {
+      rethrowTrelloError(
+        error,
+        'Card or label not found. Verify the card_id and label_id.'
+      );
+    }
+  },
+});

package/src/lib/actions/ai/add-member-to-card.ts

@@ -0,0 +1,57 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  httpClient,
+  HttpRequest,
+  HttpMethod,
+} from '@agnocon/pieces-common';
+import { trelloCommon } from '../../common';
+import { trelloAuth } from '../../..';
+import { withAuthParams, rethrowTrelloError } from './ai-common';
+import { addMemberToCardActionOutputSchema } from '../../output-schemas';
+
+export const addMemberToCard = createAction({
+  auth: trelloAuth,
+  name: 'add_member_to_card',
+  displayName: 'Add Member To Card (Agent)',
+  description: 'Assign a member to a Trello card.',
+  audience: 'ai',
+  outputSchema: addMemberToCardActionOutputSchema,
+  aiMetadata: {
+    description:
+      'Assigns a member to a Trello card. Obtain card_id from Search Cards and member_id from Search Members or List Board Members. Re-adding an already-assigned member converges to the same member set (Trello returns the full member list rather than a clean no-op), so it is idempotent.',
+    idempotent: true,
+  },
+  props: {
+    card_id: Property.ShortText({
+      displayName: 'Card ID',
+      description: 'The ID of the card. Obtain it from Search Cards.',
+      required: true,
+    }),
+    member_id: Property.ShortText({
+      displayName: 'Member ID',
+      description:
+        'The member id to assign. Obtain it from Search Members or List Board Members.',
+      required: true,
+    }),
+  },
+
+  async run(context) {
+    try {
+      const request: HttpRequest = {
+        method: HttpMethod.POST,
+        url: `${trelloCommon.baseUrl}cards/${context.propsValue['card_id']}/idMembers`,
+        headers: { Accept: 'application/json' },
+        queryParams: withAuthParams(context.auth, {
+          value: context.propsValue['member_id'],
+        }),
+      };
+      const response = await httpClient.sendRequest(request);
+      return response.body;
+    } catch (error: any) {
+      rethrowTrelloError(
+        error,
+        'Card or member not found. Verify the card_id and member_id.'
+      );
+    }
+  },
+});

package/src/lib/actions/ai/add-reaction-to-comment.ts

@@ -0,0 +1,61 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  httpClient,
+  HttpRequest,
+  HttpMethod,
+} from '@agnocon/pieces-common';
+import { trelloCommon } from '../../common';
+import { trelloAuth } from '../../..';
+import { withAuthParams, rethrowTrelloError } from './ai-common';
+import { addReactionToCommentActionOutputSchema } from '../../output-schemas';
+
+export const addReactionToComment = createAction({
+  auth: trelloAuth,
+  name: 'add_reaction_to_comment',
+  displayName: 'Add Reaction To Comment (Agent)',
+  description: 'React (emoji) to a Trello comment.',
+  audience: 'ai',
+  outputSchema: addReactionToCommentActionOutputSchema,
+  aiMetadata: {
+    description:
+      'Adds an emoji reaction to a comment action on a Trello card. Provide the comment id (action_id) from List Card Comments and identify the emoji by its shortName (e.g. "thumbsup"). Each call adds a reaction, so it is not idempotent.',
+    idempotent: false,
+  },
+  props: {
+    action_id: Property.ShortText({
+      displayName: 'Comment ID',
+      description:
+        'The comment (action) id to react to. Obtain it from List Card Comments.',
+      required: true,
+    }),
+    short_name: Property.ShortText({
+      displayName: 'Emoji Short Name',
+      description: 'The emoji short name, e.g. "thumbsup", "heart", "tada".',
+      required: true,
+    }),
+  },
+
+  async run(context) {
+    try {
+      const request: HttpRequest = {
+        method: HttpMethod.POST,
+        url: `${trelloCommon.baseUrl}actions/${context.propsValue['action_id']}/reactions`,
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json',
+        },
+        queryParams: withAuthParams(context.auth),
+        body: {
+          shortName: context.propsValue['short_name'],
+        },
+      };
+      const response = await httpClient.sendRequest(request);
+      return response.body;
+    } catch (error: any) {
+      rethrowTrelloError(
+        error,
+        'Comment (action) not found. Verify the action_id (resolve it via List Card Comments).'
+      );
+    }
+  },
+});

package/src/lib/actions/ai/ai-common.ts

@@ -0,0 +1,40 @@
+import { QueryParams } from '@agnocon/pieces-common';
+
+/**
+ * Shared helpers for the audience:'ai' Trello atomics. Trello auth is the
+ * BasicAuth API key + token passed as ?key=&token= query params (auth.username
+ * = API key, auth.password = token) — the same pattern every existing action
+ * uses. These helpers keep the agent atomics DRY without changing that pattern.
+ */
+
+export type TrelloAuthValue = { username: string; password: string };
+
+/** Build the ?key=&token= auth query-param suffix the Trello REST API expects. */
+export function authQuery(auth: TrelloAuthValue): string {
+  return `?key=${auth.username}&token=${auth.password}`;
+}
+
+/** Auth params merged into a QueryParams object (for requests that pass queryParams). */
+export function withAuthParams(
+  auth: TrelloAuthValue,
+  params: QueryParams = {}
+): QueryParams {
+  return { ...params, key: auth.username, token: auth.password };
+}
+
+/** Map a Trello HTTP error to a clear, per-status message; rethrow otherwise. */
+export function rethrowTrelloError(error: any, notFoundHint: string): never {
+  const status = error?.response?.status;
+  if (status === 401 || status === 403) {
+    throw new Error(
+      'Permission denied. Check the connection token and that the connected user has the required access (some board/organization actions require admin permission).'
+    );
+  }
+  if (status === 404) {
+    throw new Error(notFoundHint);
+  }
+  if (status === 429) {
+    throw new Error('Trello rate limit exceeded. Retry after a short delay.');
+  }
+  throw error;
+}

package/src/lib/actions/ai/archive-all-cards-in-list.ts

@@ -0,0 +1,47 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  httpClient,
+  HttpRequest,
+  HttpMethod,
+} from '@agnocon/pieces-common';
+import { trelloCommon } from '../../common';
+import { trelloAuth } from '../../..';
+import { withAuthParams, rethrowTrelloError } from './ai-common';
+
+export const archiveAllCardsInList = createAction({
+  auth: trelloAuth,
+  name: 'archive_all_cards_in_list',
+  displayName: 'Archive All Cards In List (Agent)',
+  description: 'Archive every card in a Trello list.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Archives every card in a Trello list identified by list_id (recoverable bulk archive). Obtain list_id from List Lists. This is a bulk mutation, so it is not idempotent.',
+    idempotent: false,
+  },
+  props: {
+    list_id: Property.ShortText({
+      displayName: 'List ID',
+      description: 'The ID of the list. Obtain it from List Lists.',
+      required: true,
+    }),
+  },
+
+  async run(context) {
+    try {
+      const request: HttpRequest = {
+        method: HttpMethod.POST,
+        url: `${trelloCommon.baseUrl}lists/${context.propsValue['list_id']}/archiveAllCards`,
+        headers: { Accept: 'application/json' },
+        queryParams: withAuthParams(context.auth),
+      };
+      const response = await httpClient.sendRequest(request);
+      return response.body;
+    } catch (error: any) {
+      rethrowTrelloError(
+        error,
+        'List not found. Verify the list_id (resolve it via List Lists).'
+      );
+    }
+  },
+});

package/src/lib/actions/ai/archive-board.ts

@@ -0,0 +1,58 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  httpClient,
+  HttpRequest,
+  HttpMethod,
+} from '@agnocon/pieces-common';
+import { trelloCommon } from '../../common';
+import { trelloAuth } from '../../..';
+import { withAuthParams, rethrowTrelloError } from './ai-common';
+import { archiveBoardActionOutputSchema } from '../../output-schemas';
+
+export const archiveBoard = createAction({
+  auth: trelloAuth,
+  name: 'archive_board',
+  displayName: 'Archive Board (Agent)',
+  description: 'Close (archive) or reopen a Trello board.',
+  audience: 'ai',
+  outputSchema: archiveBoardActionOutputSchema,
+  aiMetadata: {
+    description:
+      'Closes (archives, closed=true) or reopens (closed=false) a Trello board identified by board_id. Archiving is recoverable; prefer this over permanently deleting a board. Obtain board_id from List Boards. Setting the same closed state again converges, so it is idempotent.',
+    idempotent: true,
+  },
+  props: {
+    board_id: Property.ShortText({
+      displayName: 'Board ID',
+      description: 'The ID of the board. Obtain it from List Boards.',
+      required: true,
+    }),
+    closed: Property.Checkbox({
+      displayName: 'Closed',
+      description: 'True to close (archive) the board, false to reopen it.',
+      required: false,
+      defaultValue: true,
+    }),
+  },
+
+  async run(context) {
+    const closed = context.propsValue['closed'] ?? true;
+    try {
+      const request: HttpRequest = {
+        method: HttpMethod.PUT,
+        url: `${trelloCommon.baseUrl}boards/${context.propsValue['board_id']}/closed`,
+        headers: { Accept: 'application/json' },
+        queryParams: withAuthParams(context.auth, {
+          value: closed ? 'true' : 'false',
+        }),
+      };
+      const response = await httpClient.sendRequest(request);
+      return response.body;
+    } catch (error: any) {
+      rethrowTrelloError(
+        error,
+        'Board not found. Verify the board_id (resolve it via List Boards).'
+      );
+    }
+  },
+});