Skip to main content
Glama

pounce 🦊

An MCP server for Targetprocess: lets AI assistants read and manage your cards through the Targetprocess REST API. Tested against Targetprocess 2609.2 (Pro edition). Releases are listed in CHANGELOG.md.

  • Full coverage. If Targetprocess exposes an operation, pounce can perform it. Generic tools are driven by your instance's own API metadata, so custom entity types and future Targetprocess versions are covered automatically.

  • Tools that fit how teams work. Workflow tools accept names instead of ids ("move #36400 to Coded", "assign Foxxo as Developer") and apply the team's rules: effort is booked per role, default assignees are cleared on creation, and side effects on parent cards are reported.

  • Honest results. Every list is fully paged, every error carries Targetprocess's own message, and every write is read back to confirm it stuck.

  • Simple permissions. Tools are grouped by tier, so an MCP client needs one rule per tier.

Requirements

  • Node.js 22.12 or newer (npx comes with it)

  • A Targetprocess access token: in Targetprocess, open your profile → Access Tokens → create one

Nothing to download or build: your MCP client starts pounce with npx, which fetches @redfoxxo/pounce from npm on first use. @1 keeps you on 1.x releases.

Related MCP server: Tonle OpenProject MCP Server

Setup

pounce reads its settings from environment variables, which your MCP client passes to it:

Variable

Required

Purpose

TP_BASE_URL

yes

Your instance, e.g. https://yourcompany.tpondemand.com (no /api/...). https only, except for localhost

TP_TOKEN

yes

Your access token. Never logged

TP_DEFAULT_PROJECT_ID

no

Project for new cards that have no parent to inherit one from

TP_DEFAULT_TEAM_ID

no

Team for new cards when none is given

POUNCE_TOOLSETS

no

Tool groups to expose, comma-separated: cards, raw, admin (default: all three). See Tools

Keep the token out of config files: export it in your shell profile (export TP_TOKEN=...) and let the client pass it through, as the examples below do.

pounce sends nothing to Targetprocess until a tool is called. Tools read your instance's API metadata as they need it: the first card read costs two or three extra read-only requests, kept for the rest of the session. If the metadata cannot be read, a built-in copy stands in and pounce tries again on the next call.

Claude Code

Register the server once for all your projects. ${TP_TOKEN} is read from your environment when the server starts, so the token is not stored in the config:

claude mcp add-json pounce --scope user '{
  "type": "stdio",
  "command": "npx",
  "args": ["-y", "@redfoxxo/pounce@1"],
  "env": {
    "TP_BASE_URL": "https://yourcompany.tpondemand.com",
    "TP_TOKEN": "${TP_TOKEN}"
  }
}'

Then add the permission rules to ~/.claude/settings.json:

{
  "permissions": {
    "allow": ["mcp__pounce__read_*"],
    "ask": ["mcp__pounce__write_*", "mcp__pounce__delete_*"],
    "deny": ["mcp__pounce__admin_*"]
  }
}

Claude Code names MCP tools mcp__<server>__<tool>, so the server name must be pounce for these rules to match. Check the connection with claude mcp get pounce, or /mcp inside a session.

opencode

Add the server and the permission rules to opencode.json (global: ~/.config/opencode/opencode.json):

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "servers": {
      "pounce": {
        "type": "local",
        "command": ["npx", "-y", "@redfoxxo/pounce@1"],
        "environment": {
          "TP_BASE_URL": "https://yourcompany.tpondemand.com",
          "TP_TOKEN": "{env:TP_TOKEN}"
        }
      }
    }
  },
  "permissions": [
    { "action": "pounce_read_*", "resource": "*", "effect": "allow" },
    { "action": "pounce_write_*", "resource": "*", "effect": "ask" },
    { "action": "pounce_delete_*", "resource": "*", "effect": "ask" },
    { "action": "pounce_admin_*", "resource": "*", "effect": "deny" }
  ]
}

opencode names MCP tools <server>_<tool>, so the server name must be pounce for these rules to match (read_card becomes pounce_read_card). Restart opencode after changing the file; opencode mcp list shows whether it connected.

Other MCP clients

Any client that starts local (stdio) servers works. Most accept an mcpServers block like this one (Claude Desktop, Cursor, ...):

{
  "mcpServers": {
    "pounce": {
      "command": "npx",
      "args": ["-y", "@redfoxxo/pounce@1"],
      "env": {
        "TP_BASE_URL": "https://yourcompany.tpondemand.com",
        "TP_TOKEN": "your-access-token"
      }
    }
  }
}

Then map the four tool-name prefixes below to the client's permission system.

Tools

Permission tiers

Every tool name starts with its tier, so one rule per tier covers all tools, including ones added in later versions. Read tools are also marked read-only in the MCP tool annotations.

Prefix

What it does

Suggested rule

read_

Reads only

allow

write_

Creates and updates cards, comments, time, relations, ...

ask

delete_

Deletes

ask

admin_

Changes configuration (projects, teams, users, processes, workflows, ...); needs an administrator token

deny

Toolsets

58 tools in three toolsets. The client sends every listed tool to the model on every request, so expose only the toolsets you use: POUNCE_TOOLSETS=cards gives 34 tools, the day-to-day work on cards, for about 4,000 tokens; all 58 cost about 7,500.

cards (34): the workflow tools, plus card history and attachments.

  • read: read_card, read_search, read_my_work, read_states, read_people, read_teams, read_roles, read_projects, read_releases, read_iterations, read_custom_field_options, read_comments, read_relations, read_times, read_attachments, read_test_plan, read_history

  • write: write_create_card, write_update_card, write_set_state, write_assign, write_unassign, write_set_role_effort, write_set_custom_fields, write_team, write_comment, write_log_time, write_relate, write_follow, write_test_cases, write_test_run, write_attachment

  • delete: delete_card, delete_relation

raw (18): the generic tools, the escape hatch that reaches every resource and operation your instance reports.

  • read: read_meta, read_get, read_query, read_collection, read_v2_query, read_context, read_conversions, read_deleted, read_storage

  • write: write_create, write_update, write_bulk, write_collection_add, write_storage

  • delete: delete_entity, delete_bulk, delete_collection_remove, delete_storage

admin (6): admin_create, admin_update, admin_delete, admin_collection_add, admin_collection_remove, admin_undelete

Rules the workflow tools enforce

  • Effort belongs to a role. write_set_role_effort writes role effort rows; the card total is computed by Targetprocess and is never written directly.

  • Changing a task's role effort makes Targetprocess recalculate its user story; the story's before/after values are reported.

  • Cards created with write_create_card lose the assignments Targetprocess adds by default, including ones it adds a moment later, and get exactly the people you asked for. What was removed is reported. On existing cards nobody is removed unless you ask (exclusive).

  • State changes and new children report the parent card's state before and after.

  • New cards inherit the parent's project. If no project can be resolved, nothing is sent.

  • A card with child cards is deleted only with withChildren: true.

  • Names are resolved, never guessed: an ambiguous name returns every candidate with its id.

  • Time is logged where your process keeps it: standard Time entries, or, on instances that track time in a custom TimeRecord type (hours and date fields), a time record linked to the person and the card.

  • Descriptions and comments can be written as Markdown (format: "markdown"), HTML or plain text, and are read back as Markdown either way.

  • Every write is read back, and any value that did not persist is listed under notPersisted. If a multi-step write fails partway, the error says what was already done.

  • Attachments are uploaded from base64 content; pounce never reads local files.

Limitations

  • Downloading attachments is not supported. With an access token, Targetprocess returns an HTML page instead of the file.

  • Automation rules, validation rules, mashups and CSV import have no REST management API and are out of scope.

Development

Building from source, running the tests and releasing are described in DEVELOPMENT.md.

License

MIT

Available Tools

58 tools
admin_collection_addB

Add items to a collection of an administration entity, e.g. Team TeamMembers (Project, Team, User, Process, Workflow, Role, CustomField, ...); needs an administrator token.

Inputs: id (required), items (required), resource (required), collection (required).

admin_collection_removeB

Remove items from a collection of an administration entity (Project, Team, User, Process, Workflow, Role, CustomField, ...); needs an administrator token.

Inputs: id (required), childIds (required), resource (required), collection (required).

admin_createA

Create an administration entity (Project, Team, User, Process, Workflow, Role, CustomField, ...); needs an administrator token.

Inputs: fields (required), resource (required).

admin_deleteB

Delete an administration entity (Project, Team, User, Process, Workflow, Role, CustomField, ...); needs an administrator token.

Inputs: id (required), resource (required).

admin_undeleteA

Restore deleted entities by id and entity type; needs an administrator token. Comments cannot be undeleted.

Inputs: items (required).

admin_updateB

Update an administration entity (Project, Team, User, Process, Workflow, Role, CustomField, ...); needs an administrator token.

Inputs: id (required), fields (required), resource (required).

delete_bulkC

Delete up to 500 entities of one resource by id (raw).

Inputs: ids (required), resource (required).

delete_cardC

Delete a card by id; reports what was deleted and the parent card's state and efforts before/after.

Inputs: id (required), withChildren.

delete_collection_removeC

Remove items from a collection of any entity by child id (raw), e.g. unlink test cases from a test plan.

Inputs: id (required), childIds (required), resource (required), collection (required).

delete_entityC

Delete one entity of any resource (raw); reports what was deleted.

Inputs: id (required), resource (required).

delete_relationC

Delete the relation between two cards, in either direction.

Inputs: id (required), to (required), relation.

delete_storageB

Delete one storage entry (owner or admin only).

Inputs: key (required), group (required).

read_attachmentsA
Read-only

Attachments of a card with name, size, owner, date and URL. URLs need Basic or cookie auth, not the token.

Inputs: id (required).

read_cardA
Read-only

Read a card by id: state, project, parents, teams, assignments, role efforts, custom fields, tags, description.

Inputs: id (required).

read_collectionB
Read-only

Get an inner collection of an entity, e.g. UserStories/{id}/Tasks (raw), fully paged.

Inputs: id (required), resource (required), collection (required), limit, +6 more.

read_commentsB
Read-only

Comments on a card as plain text, oldest first, with author and reply parent.

Inputs: id (required), limit.

read_contextC
Read-only

Targetprocess Context for entities, projects or teams: processes, practices, terms, custom field definitions.

Inputs: ids, acid, teamIds, projectIds.

read_conversionsB
Read-only

Type conversions of a card: its current id if it was converted, and the ids it was converted from.

Inputs: id (required).

read_custom_field_optionsC
Read-only

Custom fields of a card's type, or of a type in a project, with the allowed dropdown values.

Inputs: id, type, field, project.

read_deletedA
Read-only

Deleted projects or users, with their delete date (restore: admin_undelete).

Inputs: kind (required), limit.

read_getA
Read-only

Get one entity of any resource by id (raw). Prefer read_card for cards.

Inputs: id (required), resource (required), append, exclude, +1 more.

read_historyA
Read-only

Change history of an entity, oldest first: state, effort, release, iteration; full: true for every field change.

Inputs: id (required), full, limit, resource.

read_iterationsA
Read-only

Team or project iterations (sprints), newest first; without team or project, every team's current ones.

Inputs: team, limit, project, currentOnly.

read_metaA
Read-only

Describe this instance's resources, or one resource's fields and collections. Use it before other raw tools.

Inputs: resource.

read_my_workA
Read-only

Cards assigned to the current user (the token owner), open ones by default, with counts per state.

Inputs: type, limit, state, includeClosed.

read_peopleA
Read-only

Find people by name, login or email (every word must match); without a query, everyone active.

Inputs: limit, query, includeInactive.

read_projectsB
Read-only

List projects (active by default) with abbreviation and process.

Inputs: query, includeInactive.

read_queryB
Read-only

Query any resource with where/include/orderBy (raw), fully paged. Use include to keep results small.

Inputs: resource (required), limit, where, append, +4 more.

read_relationsB
Read-only

Relations of a card in both directions, with the related card.

Inputs: id (required).

read_releasesC
Read-only

Releases, newest first, optionally for one project.

Inputs: limit, project, currentOnly.

read_rolesB
Read-only

List roles; hasEffort tells whether a role can carry effort.

Inputs: no named parameters.

read_statesB
Read-only

States of a card's own workflow, or of a type in a project; team workflow states are flagged isTeamWorkflow.

Inputs: id, type, project.

read_storageA
Read-only

RESTful storage (views, boards, settings): list groups, a group's storages, or one storage by group and key.

Inputs: key, group, limit, where, +1 more.

read_teamsA
Read-only

List teams (active by default), optionally filtered by name.

Inputs: query, includeInactive.

read_test_planC
Read-only

A test plan with its test cases and ordered steps, child test plans, and recent runs.

Inputs: id (required), runs.

read_timesB
Read-only

Time logged on a card or by a person, optionally between dates, with the total spent.

Inputs: id, to, from, user, +1 more.

read_v2_queryA
Read-only

Targetprocess v2 query (raw): select, where with and/or, aggregations. v2 omits null fields: absence means null.

Inputs: entity (required), limit, where, filter, +4 more.

write_assignA

Assign a person to a card in a role, adding to existing assignments; reads the assignments back.

Inputs: id (required), role (required), user (required), exclusive.

write_attachmentB

Upload base64-encoded files to a card and read them back; pounce never reads local files.

Inputs: id (required), files (required).

write_bulkA

Create or update up to 500 entities of one resource (raw); items with "Id" update. Nothing is sent if one is invalid.

Inputs: items (required), resource (required).

write_collection_addB

Append items to a collection of any entity (raw); nothing is replaced.

Inputs: id (required), items (required), resource (required), collection (required).

write_commentB

Add a comment to a card, or reply to one with replyTo.

Inputs: id (required), text (required), format, private, +1 more.

write_createA

Create an entity of any resource (raw), validated against the catalog. Prefer write_create_card for cards.

Inputs: fields (required), resource (required).

write_create_cardC

Create a card under its parent, inheriting the project; replaces default assignees with the requested ones, reports parent changes.

Inputs: name (required), type (required), tags, state, +12 more.

write_followA

Follow (or with unfollow: true, stop following) a card, for yourself or another person.

Inputs: id (required), user, unfollow.

write_log_timeC

Log time spent on a card for a person (default: you, today). Creates a Time entry or a time record, as the process tracks it.

Inputs: id (required), spent (required), date, role, +3 more.

write_relateB

Relate two cards (Relation by default; Dependency, Blocker, Link, Duplicate, ...). An identical relation is left alone.

Inputs: id (required), to (required), relation, direction.

write_set_custom_fieldsB

Set custom fields by name, e.g. {"BackEnd":"Done"}; dropdown values are validated first, null clears.

Inputs: id (required), fields (required).

write_set_role_effortA

Set effort per role on a card (never the card total). A task's efforts roll up into its story; both are reported.

Inputs: id (required), efforts (required).

write_set_stateB

Move a card, or one team's state on it, to a state by name or id; reports the parent card's state change.

Inputs: id (required), state (required), team.

write_storageA

Create or merge a storage entry: posted keys are set, other keys kept, null deletes a key. Owner or admin only.

Inputs: group (required), key, scope, userData, +1 more.

write_teamC

Add or remove teams on a card (names or ids).

Inputs: id (required), add, remove.

write_test_casesC

Create test cases with ordered steps under a test plan; each case is read back.

Inputs: cases (required), testPlan (required).

write_test_runC

Record a run of a test plan, with a result per test case (Passed, Failed, Blocked, OnHold, NotRun).

Inputs: testPlan (required), name, results.

write_unassignB

Remove one person's assignment from a card; role is required when they hold several.

Inputs: id (required), user (required), role.

write_updateB

Update fields of any entity (raw), validated and read back. Card effort: use write_set_role_effort.

Inputs: id (required), fields (required), resource (required).

write_update_cardC

Update a card's name, description, tags, release, iteration, parent or other fields; changes are read back.

Inputs: id (required), name, tags, fields, +8 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3/5.0

    Scored across 58 tools

    Disambiguation3/5

    Many tools are clearly scoped, but the surface intentionally duplicates high-level card operations with raw generic CRUD: read_card/read_get, write_create_card/write_create, write_update_card/write_update, and delete_card/delete_entity. The descriptions do recommend preferences, but with 58 tools an agent still faces multiple plausible entry points for similar actions.

    Naming Consistency4/5

    Names consistently use read_, write_, delete_, and admin_ prefixes with mostly verb_noun structure. Minor deviations exist, such as write_team for adding/removing teams, write_attachment for uploading, and write_follow covering both follow and unfollow.

    Tool Count2/5

    58 tools is a very large surface for one MCP server, especially because it includes both specialized card tools and raw generic CRUD/admin variants. The breadth is partly justified by Targetprocess's large domain, but many tools could be consolidated or made less redundant.

    Completeness4/5

    Coverage is broad: cards, states, projects, teams, people, roles, releases, iterations, comments, relations, time, attachments, tests, history, storage, admin, and raw entity operations. Some lifecycle gaps remain, such as editing/deleting comments or attachments, though raw tools can cover many missing paths.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      Not graded
      maintenance
      Provides tools for interacting with Targetprocess, a project management and agile planning platform, enabling AI assistants to search, create, and update project entities with proper validation.
      3
      -
    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI assistants to interact with OpenProject's API v3 for comprehensive project management operations including work packages, projects, time tracking, users, and all other OpenProject features through natural language.
      5
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI assistants to interact with Targetprocess for search, create, update, and query of entities like User Stories and Bugs, with support for complex filters and data model discovery.
      MIT