Play includes a Source Control feature for Git-backed assets. It lets your team connect a repository, track changes on individual assets, commit updates, push them to the tracked branch, pull the latest branch state, inspect version history, and resolve conflicts when local and remote changes diverge.
What this feature does
-
Connects a Git provider to a team through reusable source-control connectors
-
Lets a team mark one connector as the default connector for version control
-
Binds supported assets to a repository file path and branch
-
Tracks whether an asset is synced, uncommitted, pushed, behind, or in conflict
-
Supports committing one or more changed assets together
-
Supports commit-and-push workflows to the tracked branch
-
Refreshes git state to detect remote updates and pull safe changes down
-
Shows version history and commit details for a tracked asset
-
Lets you revert an asset to an earlier committed version by creating a new commit
-
Helps you resolve conflicts when the branch changed while you still had local edits
Where to find it
-
Team Settings->Source Control: create and manage connectors -
Typescript asset editor ->
Version controltab: asset-level git status and actions -
Left sidebar ->
Source Control: team-wide overview of uncommitted, pushed, synced, and conflict states
Before you start
To use version control in Play, you need:
-
access to the target repository or organization
-
a GitHub Personal Access Token (PAT) or equivalent key
-
the right repository permissions for the workflow you want to enable
-
a team admin to configure the connector
Permissions and access
The connector token must be able to see the repository and validate branch information.
For most version-control workflows, Play needs:
-
Metadata read access: to discover repositories, branches, and commit information
-
Contents read/write access: to read tracked files and, for Git-backed asset workflows, create commits or push updates
Use the minimum repository access your workflow needs. If your team only imports repository files into a Knowledge Base, read-only access is enough for that import flow. If your team uses Git-backed asset version control, commit and push workflows require write-capable repository access.
Set up a connector
-
Open
Team Settings. -
Go to
Source Control. -
Select
+ New connector. -
Choose the provider.
-
Paste the PAT or key with the required permissions. Play shows the authenticated GitHub account automatically.
-
Choose a repository and branch. Repository names include their owner, such as
organization/repository. -
If this connector should back asset version control, turn on
Use this connector for version control. -
Select
Test connectionand save the connector.
After the connector is saved, Play can use it for repository selection, branch lookup, commit publishing, and version-history operations.
The repository list can include repositories owned by your account, organizations you belong to, and repositories shared with you as a collaborator. A listed repository is not proof that the token can push to it. Commit and push actions also require Contents: Read and write for that repository and permission to update the target branch.
Assets that Play tracks
Play's version-control workflow currently tracks these asset kinds:
-
TypeScript assets: reusable Playwright or helper-code assets that are edited directly as source files
-
Test case assets: automation assets that your team wants to keep mapped to files in the connected repository
-
Agent assets: supported agent code assets that participate in the same git-backed tracking flow
In the UI today:
-
supported assets expose their own Version control section for asset-level status and actions
-
the team-wide Source Control panel can show tracked supported assets across the team, including untracked assets that are ready to be bound to git
For every tracked asset, Play stores the repository, branch, and mapped file path so the product knows exactly which git-backed file the asset belongs to.
How assets are tracked
When an asset is connected to source control, Play keeps track of:
-
the repository
-
the base branch
-
the mapped file path
-
whether the local draft differs from the last synced git baseline
-
whether the branch moved ahead remotely
-
whether the asset has already been committed or pushed
-
whether the asset needs attention because of a conflict or auth issue
This lets the Source Control views show whether an asset is:
-
synced: local draft matches the tracked git baseline
-
uncommitted: local draft changed and has not been committed yet
-
pushed: the asset has already been committed and pushed to the tracked branch
-
behind: the tracked branch has newer remote changes
-
conflict: local and remote changes both need resolution before Play can safely continue
Commit changes
You can commit a single asset or several assets together from the Source Control workflow.
When you commit:
-
Play groups the selected changes by repository and branch
-
each group is committed atomically
-
if any file in a group conflicts, that group is not partially committed
-
the result shows which assets committed successfully and which need attention
You can provide a commit message, or let the workflow use the product defaults where applicable.
Push flow
Play currently supports a push-based publish flow.
When you push:
-
Play commits the asset changes
-
pushes those changes to the tracked branch
-
updates the asset status so the team can see that the latest local work is now in git
The Source Control panel shows pushed assets separately from uncommitted and synced assets so you can quickly see what has already been sent to the repository.
Pull and refresh
Play separates refreshing status from pulling content so teams can see incoming branch changes without overwriting drafts unexpectedly.
Refresh
Use Refresh when you want Play to re-check git state:
-
detect whether the remote branch head changed
-
update the asset's behind / synced / conflict status
This is similar to asking Play to re-evaluate the asset against the current repository state.
Pull latest
Use Pull latest when you want the newest branch version to come into Play.
When the asset is clean, Play can safely bring in the newer remote version.
When the asset has local edits and the branch also changed, Play protects the draft by treating that as a conflict instead of silently overwriting your work.
Version history and versioning
Tracked assets keep a version history tied to git-backed states.
From version history, you can:
-
see earlier versions of the asset
-
inspect commit history
-
open commit details
-
review which files changed in a commit
-
read the commit message, author, and authored time
This gives teams a practical versioning trail for each tracked asset instead of relying only on the current draft.
Revert to an earlier version
If you need to restore an older committed state, Play supports reverting from history.
When you revert:
-
you choose an earlier commit from the version graph or commit history
-
Play restores that older state as a new change
-
the revert is recorded as a new commit rather than deleting history
That keeps the audit trail intact while still letting you move an asset back to a known-good version.
Conflicts
Conflicts happen when Play cannot safely combine the local draft with the latest branch state.
Common causes include:
-
you edited the asset locally while the tracked branch also changed remotely
-
the asset is behind and still dirty
-
the remote file changed in a way that prevents a safe automatic update
When this happens, Play marks the asset as needing attention instead of guessing which version to keep.
Conflict resolution options
Depending on the asset state, Play can offer actions such as:
-
Preview differences: compare the local draft with the remote version
-
Keep local changes and update the git baseline: preserve your draft while rebasing the tracked baseline to the newest branch version
-
Keep remote changes: discard the current local draft and replace it with the latest branch version
-
Restore last synced git version: discard local uncommitted changes and return to the last synced state
These flows are designed to prevent accidental loss of work while still giving a clear path out of the conflict.
Team-wide Source Control panel
The Source Control panel gives a shared view across tracked assets in the team.
It helps you:
-
review everything currently uncommitted
-
see which assets have already been pushed
-
identify synced assets
-
find conflicts and other items that need attention
-
commit several assets together from one place
-
refresh or pull updates across many assets
This is useful when several people are working in the same repository-backed workflow and need a single operational view.
Best practices
-
Use a dedicated connector with the smallest repository scope that still supports your workflow
-
Use read-only access for repository-import scenarios and write-capable access only for Git-backed asset version control
-
Refresh before a larger commit if several teammates are working on the same branch
-
Pull clean assets early so conflicts are found sooner, not at commit time
-
Use clear commit messages when batching several assets together
-
Resolve conflicts intentionally rather than forcing a destructive overwrite