list_rewrites

Instructions

Implementation Reference

• migadu_mcp/tools/rewrite_tools.py:18-22 (handler)

  The 'list_rewrites' MCP tool handler – defined as an async function decorated with @migadu_tool. Resolves the domain and delegates to the RewriteService.list_rewrites() method. Registered via register_rewrite_tools().

  async def list_rewrites(ctx: Context, domain: str | None = None) -> dict[str, Any]:
      """List rewrite rules for a domain."""
      resolved = resolve_domain(domain)
      await ctx.info(f"📋 Listing rewrites for {resolved}")
      return await get_service_factory().rewrite_service().list_rewrites(resolved)

• migadu_mcp/services/rewrite_service.py:16-17 (helper)

  The RewriteService.list_rewrites() method – makes an HTTP GET request to the Migadu API endpoint /domains/{domain}/rewrites. This is the actual API call that fetches rewrite rules.

  async def list_rewrites(self, domain: str) -> dict[str, Any]:
      return await self.client.get(f"/domains/{domain}/rewrites")

• migadu_mcp/main.py:51-57 (registration)

  Registration in initialize_server() – the function register_rewrite_tools(mcp) is called to register all rewrite tools (including list_rewrites) with the FastMCP server instance.

  def initialize_server() -> None:
      register_domain_tools(mcp)
      register_mailbox_tools(mcp)
      register_identity_tools(mcp)
      register_alias_tools(mcp)
      register_rewrite_tools(mcp)
      register_forwarding_tools(mcp)

• migadu_mcp/tools/rewrite_tools.py:16-84 (registration)

  The register_rewrite_tools() function that defines and registers all rewrite-related tools (including list_rewrites) with the FastMCP instance via the @migadu_tool decorator.

  def register_rewrite_tools(mcp: FastMCP) -> None:
      @migadu_tool(mcp, read_only=True, summarize_response=True)
      async def list_rewrites(ctx: Context, domain: str | None = None) -> dict[str, Any]:
          """List rewrite rules for a domain."""
          resolved = resolve_domain(domain)
          await ctx.info(f"📋 Listing rewrites for {resolved}")
          return await get_service_factory().rewrite_service().list_rewrites(resolved)
  
      @migadu_tool(mcp, read_only=True)
      async def get_rewrite(
          name: str, ctx: Context, domain: str | None = None
      ) -> dict[str, Any]:
          """Get rewrite rule details by slug/name."""
          resolved = resolve_domain(domain)
          await ctx.info(f"📋 Getting rewrite {name} for {resolved}")
          return await get_service_factory().rewrite_service().get_rewrite(resolved, name)
  
      @migadu_bulk_tool(mcp, RewriteCreateRequest, entity="rewrite", idempotent=False)
      async def create_rewrite(
          item: RewriteCreateRequest, ctx: Context
      ) -> dict[str, Any]:
          """Create rewrite rule(s). List of dicts with: name, local_part_rule (pattern), destinations, domain (optional), order_num (optional)."""
          domain = item.domain or resolve_domain(None)
          destinations = [str(d) for d in item.destinations]
          await ctx.info(f"📋 Creating rewrite {item.name} on {domain}")
          result = (
              await get_service_factory()
              .rewrite_service()
              .create_rewrite(
                  domain, item.name, item.local_part_rule, destinations, item.order_num
              )
          )
          return {"rewrite": result, "success": True}
  
      @migadu_bulk_tool(mcp, RewriteUpdateRequest, entity="rewrite")
      async def update_rewrite(
          item: RewriteUpdateRequest, ctx: Context
      ) -> dict[str, Any]:
          """Update rewrite rule(s). List of dicts with: name (required), and any of: new_name, local_part_rule, destinations, order_num, domain."""
          domain = item.domain or resolve_domain(None)
          destinations = (
              [str(d) for d in item.destinations] if item.destinations else None
          )
          await ctx.info(f"📋 Updating rewrite {item.name} on {domain}")
          result = (
              await get_service_factory()
              .rewrite_service()
              .update_rewrite(
                  domain,
                  item.name,
                  item.new_name,
                  item.local_part_rule,
                  destinations,
                  item.order_num,
              )
          )
          return {"rewrite": result, "success": True}
  
      @migadu_bulk_tool(mcp, RewriteDeleteRequest, entity="rewrite", destructive=True)
      async def delete_rewrite(
          item: RewriteDeleteRequest, ctx: Context
      ) -> dict[str, Any]:
          """Delete rewrite rule(s). DESTRUCTIVE. List of dicts with: name, domain (optional)."""
          domain = item.domain or resolve_domain(None)
          await ctx.warning(f"🗑️ Deleting rewrite {item.name}")
          await get_service_factory().rewrite_service().delete_rewrite(domain, item.name)
          return {"deleted": item.name, "success": True}
  
      _ = (list_rewrites, get_rewrite, create_rewrite, update_rewrite, delete_rewrite)

• migadu_mcp/tools/resource_tools.py:139-141 (helper)

  Alternative usage as an MCP resource – the 'rewrites://{domain}' resource also calls list_rewrites() internally, exposing the same data via the resource URI pattern.

  async def domain_rewrites(domain: str, ctx: Context) -> dict[str, Any]:
      await ctx.info(f"📋 Loading rewrites for {domain}")
      return await get_service_factory().rewrite_service().list_rewrites(domain)