- Quick assessment
- What the app writes
- Overview
- At a glance
- App Internal (3 scopes)
- Compliance (1 scope)
- Issue & User Data (5 scopes)
- Project & Metadata (8 scopes)
- Field & Screen Configuration (12 scopes)
- JSM (2 scopes)
- Rovo (1 scope)
- Impersonation in practice
- Reviewing scopes before installing
- Compliance and Trust Center
- Next steps
Quick assessment
A 30-second read for purchasing teams and managers evaluating the app.
- Forge-native - runs entirely inside Atlassian infrastructure. No external servers, no companion apps, no third-party data stores.
- 32 declared scopes. The scope list is part of the app manifest published on Atlassian Marketplace; any change to it ships as a new major version that a site administrator must approve before it takes effect.
- Admin-controlled configuration - only Jira site administrators can install and configure the app. Project admins can manage configurations only when delegation is explicitly enabled by a site admin.
- No
external:scopes declared - the app cannot call arbitrary hosts. The only egress from the Forge runtime is the weekly GDPR account report to Atlassian’s Personal Data Reporting API. (The app’s Jira module icons are images hosted onjibrok.comand are fetched by the end user’s browser; they carry no data - see the network allowlist.) - Sandboxed template engine - templates run with no
eval, nofetch, no filesystem, no module system, with iteration and timeout limits. - Impersonation on two read scopes only - JQL and issue reads execute under
read:jira-workas the configuration’s actor, which is the viewing user by default. Names of JSM Assets objects are read underread:cmdb-object:jiraas the viewing user (as the app only on the JSM portal, for the customer’s own request). A site admin can pin a configuration to the app identity or to a named account; see Impersonation in practice. - Compliance - JiBrok maintains SOC 2 Type II certification for its organizational controls; evidence may be shared under NDA where appropriate. GDPR-aligned, single sub-processor (Atlassian Forge). See Trust Center.
What Message Field does NOT request
The app’s manifest does not include any of the following:
- Filesystem access of any kind
- Outbound HTTP to arbitrary URLs (no
external:scopes) - Storage of Jira user e-mail addresses - the only account identifier the app persists is the Atlassian account ID
- Account password resets, 2FA secrets, or session cookies
- Cross-site Jira data (each Jira site is a separate Forge installation with isolated storage)
- Atlassian Marketplace billing data, vendor analytics, or other vendor APIs
- Issue mutations - the app does not declare
write:jira-workand cannot create, update, transition, or delete issues. It does write to Jira, through five administrative write scopes (app properties, UI Modifications and Message custom-field registration, field configuration, field default value, screen-tab placement); none of them touches the content of a work item. See What the app writes - Sprint, board, or agile mutations
- Assets write, delete, schema or object-type scopes - the only Assets scope is the read-only
read:cmdb-object:jira, used to show Assets field values by object name; no Assets object is created, updated or deleted. See JSM
Worst case
If a malicious site administrator creates a misconfigured panel, the worst case is bounded by what that admin could already see in Jira directly. Message Field cannot escalate beyond the actor’s Jira permissions, cannot reach external services, cannot bypass tenant isolation, and cannot mutate Jira issue data. Configuration is stored in Forge KV and is visible only to Jira administrators through the app’s admin pages; uninstalling the app removes all stored configuration.
On the JSM portal a customer sees the name of an Assets object in a field of their own request that the configuration shows them, even without their own access to Assets - the same way they see the field value itself.
For setting up a production-ready configuration, follow the Admin Hardening Guide. For a security review, threat model, and DPIA-grade detail, see Security Reference for Auditors.
What the app writes
“Read-only” would be the wrong summary. Message Field declares five write scopes, and this is the complete list of what they are used for:
| Scope | What is written | Triggered by |
|---|---|---|
write:app-data:jira |
The app’s own app properties - module status and the configuration matrix that displayConditions expressions evaluate |
Saving a configuration or a module toggle |
write:field:jira |
The Message custom field itself, and the UI Modifications the app registers to drive the JSM portal and custom-field create surfaces | The jira:uiModifications module; the uim-sync-scheduler hourly reconciliation; creating a Message custom field |
write:field-configuration:jira |
Field-configuration entries for the Message custom field | The jira:uiModifications module declaration |
write:field.default-value:jira |
The Message custom field’s value for a field context - a configuration identifier | The jira:uiModifications module declaration; custom-field setup |
write:screen-tab:jira |
Placement of the Message custom field on a screen tab | The jira:uiModifications module declaration |
What is not written: work item fields, comments, worklogs, transitions, attachments, entity properties on issues / projects / users, or any field the app does not own. write:jira-work is not declared, so none of that is reachable.
The four write:field* / write:screen-tab scopes are the scope set that Forge requires for the jira:uiModifications module. They are declared because that module is declared - not because an administrator flow in the app creates fields or edits screens on its own.
Overview
Message Field for Jira Cloud declares 32 OAuth scopes in its Forge manifest. The list is shown to your Jira admin during installation and again whenever a release changes it - such a release is a new major version that requires administrator approval.
This page lists every scope by name, explains what it enables, and shows whether it runs as the app or as a real user (impersonation). It is the canonical reference for the app’s permissions and is the companion to the Admin Hardening Guide and the Security Reference for Auditors.
Why these scopes
Atlassian intentionally splits broad permissions into narrow, single-purpose scopes. Reading an issue, reading its status, reading its priority, and reading its labels are four separate scopes - the app cannot ask for one “full access” permission instead. The number of scopes reflects the surface area of features Message Field supports (issue panels, custom field, JSM portal modules, UI Modifications, Rovo agents) - not the level of access per scope.
What “Impersonation” means in this page
Some scopes are declared with allowImpersonation: true in the manifest. When the app reads issue data on behalf of the viewing user, those calls inherit that user’s Jira permissions. A user only sees panel content for issues they have Browse Projects permission on; if they cannot see an issue in Jira, they cannot see it through a panel.
In Message Field, two read scopes are impersonation-aware: read:jira-work and read:cmdb-object:jira. read:cmdb-object:jira is used both as the viewing user (a licensed Jira user - Assets applies that user’s permissions, and an object they cannot read stays shown as #objectId) and as the app (on the JSM portal, only for the fields of the customer’s own request that the configuration shows them). Every other scope runs as the app and is reserved for administrative configuration tasks (registering UI modifications, reading screen schemes, writing field defaults) where a per-call user identity is not meaningful.
See Impersonation in practice below.
At a glance
| Category | Count | Impersonation | What it enables |
|---|---|---|---|
| App Internal | 3 | App-only | Storage, UI Modification registration, license check |
| Compliance | 1 | App-only | GDPR personal data reporting |
| Issue & User Data | 5 | Mixed (1 of 5) | Read issues, statuses, users; impersonation on read:jira-work |
| Project & Metadata | 8 | App-only | Read projects, components, versions, issue types, priorities, labels, locale, epic links |
| Field & Screen Configuration | 12 | App-only | Power the Message custom field and place it on screens |
| JSM | 2 | Mixed (1 of 2) | Read service desk request types for portal panels; read Assets object names for field values |
| Rovo | 1 | App-only | Receive Rovo agent invocations |
| Total | 32 | 2 impersonation / 30 app-only |
App Internal (3 scopes)
These scopes power Message Field’s own storage, UI Modification registration, and licensing. They never read or write Jira project data on behalf of a user.
| Scope | Impersonation | What it enables | Why Message Field needs it |
|---|---|---|---|
storage:app |
App-only | Read and write the app’s own Forge key-value storage | Stores all panel configurations, module enable/disable settings, delegation policy, custom field configuration mappings, and UIM registration state - all isolated per Jira site |
write:app-data:jira |
App-only | Write app properties on Jira entities | Registers per-module visibility flags and configuration matrix as Jira app properties so display conditions can be evaluated without a round-trip to the resolver |
read:license:jira |
App-only | Read the app’s license status | Gates premium behavior and shows correct license state in the admin UI |
Compliance (1 scope)
| Scope | Impersonation | What it enables | Why Message Field needs it |
|---|---|---|---|
report:personal-data |
App-only | Submit GDPR personal data reports to Atlassian | Reports the account IDs Message Field stores (creator/updater attribution on configurations) to Atlassian once a week, so Atlassian can propagate account closures and updates back to the app. Implemented by the weekly personal-data-report scheduled trigger, which also applies the erase and refresh actions Atlassian returns |
Issue & User Data (5 scopes)
read:jira-work, one of the app’s two impersonation-aware scopes, is in this category (the other, read:cmdb-object:jira, is under JSM). It backs every JQL query and issue read used to populate panel content. The granular companions are app-only because they are used at admin time for configuration UIs.
| Scope | Impersonation | What it enables | Why Message Field needs it |
|---|---|---|---|
read:jira-work |
Yes | Read issues, search issues, JQL queries | Backs panel rendering when the configured data source is Linked Issues or JQL. Inherits the viewing user’s Jira permissions on every call |
read:jira-user |
App-only | Look up Jira users | Resolves the currentUser template variable and assignee references used inside templates |
read:issue:jira |
App-only | Granular read of issue fields | Required alongside read:jira-work for the newer granular Jira API used in admin tooling and Rovo actions |
read:issue-status:jira |
App-only | Read available statuses | Powers status pickers in the configuration UI and status-aware filters in the Rovo admin agent |
read:user:jira |
App-only | Granular read of user accounts | Granular companion to read:jira-user used in admin lookups |
Project & Metadata (8 scopes)
Project, issue type, and metadata scopes power configuration UIs (project pickers, issue-type filters) and the currentUser-style template variables. None are impersonation-aware - they read configuration vocabulary that is not user-specific.
| Scope | Impersonation | What it enables | Why Message Field needs it |
|---|---|---|---|
read:project:jira |
App-only | Read projects, search projects | Backs the project picker in panel configuration and the listProjects Rovo action |
read:project.component:jira |
App-only | Read project components | Required for component-aware filters and templates |
read:project-version:jira |
App-only | Read project versions | Required for fix-version-aware filters and templates |
read:issue-type:jira |
App-only | Read available issue types | Powers issue-type filters in the configuration UI and the listIssueTypes Rovo action |
read:priority:jira |
App-only | Read priority definitions | Required for priority-aware filters and template references |
read:label:jira |
App-only | Read issue labels | Required for label-aware filters and templates |
read:user-configuration:jira |
App-only | Read user-level configuration (locale) | Required for locale-aware date and number formatting in templates |
read:epic:jira-software |
App-only | Read epic data | Lets templates and filters resolve the epic-link field on issues |
Field & Screen Configuration (12 scopes)
All Field & Screen Configuration scopes are app-only. They power the Message custom field module and the jira:uiModifications module - the UI Modifications that drive the JSM portal and custom-field create surfaces. Forge requires the four write scopes in this group for any app that declares jira:uiModifications, which is why they are present. None of these scopes can read or write work item data; they read and write the configuration metadata that determines how the custom field and the UI Modifications are registered and rendered. See What the app writes.
| Scope | Impersonation | What it enables | Why Message Field needs it |
|---|---|---|---|
read:field:jira |
App-only | Read the Jira field catalog | Powers field metadata cache and field pickers in the admin UI; backs the listFields Rovo action |
read:field-configuration:jira |
App-only | Read field configurations | Required to check whether the custom field is wired into a given field configuration |
read:custom-field-contextual-configuration:jira |
App-only | Read custom field per-project configuration | Required by the jira:customFieldType module to know which projects and issue types a given Message custom field instance applies to |
write:field-configuration:jira |
App-only | Update field configurations | Required by the jira:uiModifications module declaration - Forge demands this scope for any app that registers UI Modifications. The app does not rewrite a site’s field configurations on its own |
write:field.default-value:jira |
App-only | Set the value of the Message custom field for a field context | What is published as the field’s value is the configuration ID - a reference to the configuration to render. The rendered message is never written into the work item as text; it is produced by the field renderer at view time. Also required by the jira:uiModifications module declaration. See Custom fields |
write:field:jira |
App-only | Create and update custom fields, and register UI Modifications | Required by the jira:uiModifications module declaration, which is how the JSM portal and custom-field create surfaces are driven. Also used when an admin creates a new Message custom field instance |
read:screen-scheme:jira |
App-only | Read screen schemes | Required for screen-scheme-aware field placement |
read:issue-type-screen-scheme:jira |
App-only | Read issue-type-to-screen mappings | Required to find where the Message custom field can appear |
read:screenable-field:jira |
App-only | Read which fields can appear on a screen | Required for screen editing safety checks |
read:screen-field:jira |
App-only | Read field placement on screens | Lets the admin UI know if the Message field is already on a screen |
read:screen-tab:jira |
App-only | Read screen tabs | Required to add the Message field to the right tab |
write:screen-tab:jira |
App-only | Add the Message field to a screen tab | Required by the jira:uiModifications module declaration. The app does not reorganize screens by itself; screen placement stays an administrator action in Jira |
JSM (2 scopes)
| Scope | Impersonation | What it enables | Why Message Field needs it |
|---|---|---|---|
read:servicedesk-request |
App-only | List service desks and request types | Used at admin time only - lets the configuration UI pick a request type when registering a JSM portal panel. Backs the listRequestTypes Rovo action |
read:cmdb-object:jira |
Yes (viewer) / App (JSM portal) | Read JSM Assets objects (read-only) | Shows the value of an Assets field in messages and panels by the object’s name instead of its id or raw JSON. For a licensed viewer the name is read as that viewer, so Assets applies their permissions; an object they cannot read stays shown as #objectId. On the JSM portal the name is read as the app, only for the fields of the customer’s own request that the configuration shows them. Nothing in Assets is created, updated or deleted |
For how Message Field handles unlicensed JSM portal access, see JSM portal specifics.
Rovo (1 scope)
| Scope | Impersonation | What it enables | Why Message Field needs it |
|---|---|---|---|
read:chat:rovo |
App-only | Receive Rovo agent invocations | Required by the two rovo:agent modules - the Message Panel Agent (7 analysis actions: getMessagePanel, getStatusSummary, searchLinkedByField, buildRelationshipTree, analyzeImpact, findBlockedIssues, detectCycles) and the Message Panel Admin Agent (23 actions: configuration CRUD, reference lookups, help and diagnostics). Each agent invocation still passes through the underlying Jira scopes for any data it reads |
See Rovo Integration for setup and the agent action list.
Impersonation in practice
Message Field has two impersonation-aware scopes: read:jira-work and read:cmdb-object:jira (Assets object names, see JSM). Every panel that reads issue data passes through read:jira-work. The actor that the call is made as is controlled by the Actor setting in the panel configuration:
| Actor setting | Calls run as | Use case |
|---|---|---|
| Viewing user (default) | The user viewing the issue, via read:jira-work impersonation. Jira enforces that user’s permissions per call |
Default for issue-view and admin contexts; results vary by user permissions |
| App user | The app’s own Forge identity, used when panel content must not vary by viewer. Returns the same data regardless of who is looking | Use when configuration depends on stable results, never on portal panels facing customers |
| Application user | The same app identity in the JSM portal context, where the viewer has no Jira licence. Returns the same data for every portal visitor, so the configuration must be scoped to what portal customers may see | JSM portal panels only |
| A specific named account | The Jira account the site administrator picks for that configuration. Every read for that panel runs with that person’s Jira permissions, for every viewer | Portal and cross-project panels that need a stable, auditable identity |
Auditors: the actor is not restricted to the app identity. A site administrator can pin a configuration to any named Jira account, including a highly privileged one, and every viewer of that panel then sees data through that account’s permissions. This is the single setting in the app that can widen what a viewer sees beyond their own permissions, so it belongs in a permissions review: enumerate the configurations that do not use Viewing user and confirm the chosen account is one you would accept as a data source for that panel’s audience. Whoever the actor is, the app still cannot exceed that account’s Jira permissions.
Only site administrators can choose or change the Actor; project administrators with delegation cannot. When choosing anything other than Viewing user, be deliberate about what data is exposed - the panel content is visible to everyone who can see the panel.
Reviewing scopes before installing
When you install or upgrade Message Field, Jira shows the full list of scopes the app requests. The list comes directly from the manifest reviewed by Atlassian; it cannot be expanded silently between Marketplace releases. To see the current set without installing, check the app’s listing on the Atlassian Marketplace.
After installation, the administrative controls available on top of the declared scopes are:
- Actor (impersonation) policy - per-panel choice between Viewing user / App user / Application user, configurable only by site admins. See Impersonation in practice.
- Delegation policy - control which projects allow project admins to manage their own configurations. See Delegation.
- Module toggles - enable or disable each of the 14 rendering modules globally: issue panel, issue activity, issue context, issue action, the six JSM portal modules (panel, header, subheader, footer and the two create-form modules), the dashboard gadget, the app’s own global page and project page, and the Message custom field. There is no toggle for UI Modifications and no toggle for the Rovo agents - UIM registration follows the configurations that need it, and Rovo availability is governed at the Atlassian site level, not by this app. See Modules.
- Display conditions - admin-defined per-config visibility rules evaluated by Jira itself before the panel is rendered.
Compliance and Trust Center
The full set of declared scopes is part of Atlassian’s app review process and is referenced in our public security documentation:
- Admin Hardening Guide - Production checklist for delegation, actor policy, modules, retention, and incident response
- Security Reference for Auditors - Threat model, scope-to-data category mapping, data flow, and GDPR mapping
- Trust Center - SOC 2 Type II, GDPR, DPAs, vulnerability disclosure, and certifications
- DPA - Message Field for Jira Cloud - Data Processing Agreement
- Vulnerability Disclosure - How to report a security issue
Next steps
- Admin Hardening Guide - Day 0 / Day 1 / Week 1 production checklist
- Security Reference for Auditors - Threat model, data flow, GDPR mapping, evidence
- Delegation - Project admin access control
- Modules - Per-module enable/disable
- Limits - System limits and constraints
- FAQ - Common questions about permissions and security

