feat: PII attribute rule mapping system with extensible rule registry by Copilot · Pull Request #73 · MaximumTrainer/OpenDataMask

Copilot · 2026-04-16T16:08:11Z

…askRule, HashRule, RegexRule Agent-Logs-Url: https://github.com/MaximumTrainer/OpenDataMask/sessions/1f3e4622-ad17-4d5f-b60f-195b61c0a703 Co-authored-by: MaximumTrainer <1376575+MaximumTrainer@users.noreply.github.com>

…nullable sentinel params, docs fixes Agent-Logs-Url: https://github.com/MaximumTrainer/OpenDataMask/sessions/1f3e4622-ad17-4d5f-b60f-195b61c0a703 Co-authored-by: MaximumTrainer <1376575+MaximumTrainer@users.noreply.github.com>

Copilot

Pull request overview

Adds a configurable PII attribute rule system so users can define per-column masking behavior (including new strategies like REDACT / PARTIAL_MASK / REGEX) and have it applied during PASSTHROUGH jobs, with API + frontend type support and accompanying docs/tests.

Changes:

Introduces PIIMaskingRule + built-in rule implementations, plus a RuleRegistryPort and DefaultRuleRegistry.
Extends MaskingStrategy and persists piiRuleParams on CustomDataMapping (API/DTO + frontend TS types updated).
Applies PII mappings during JobService PASSTHROUGH processing; adds docs and unit tests.

Reviewed changes

Copilot reviewed 15 out of 15 changed files in this pull request and generated 12 comments.

Show a summary per file

File	Description
frontend/src/types/index.ts	Adds new `MaskingStrategy` enum values and `piiRuleParams` field to mapping request/response types.
docs/user-guide.md	Documents PII attribute rule mapping usage and custom rule registry integration.
docs/pii-masking-rules-sample.json	Provides an example bulk mapping configuration for PII rules.
backend/src/main/kotlin/com/opendatamask/domain/model/PIIMaskingRule.kt	Defines PII masking rule interface + built-in rule implementations.
backend/src/main/kotlin/com/opendatamask/domain/model/CustomDataMapping.kt	Extends `MaskingStrategy` and adds `piiRuleParams` column to the entity.
backend/src/main/kotlin/com/opendatamask/domain/port/output/RuleRegistryPort.kt	Adds an output port for rule lookup/registration.
backend/src/main/kotlin/com/opendatamask/application/service/DefaultRuleRegistry.kt	Implements a default in-memory registry for built-in/custom rules.
backend/src/main/kotlin/com/opendatamask/application/service/PIIMaskingService.kt	Applies mappings to rows using strategy-specific logic and params parsing.
backend/src/main/kotlin/com/opendatamask/application/service/JobService.kt	Wires `PIIMaskingService` into PASSTHROUGH table processing.
backend/src/main/kotlin/com/opendatamask/application/service/CustomDataMappingService.kt	Persists/returns `piiRuleParams` for single and bulk mapping operations.
backend/src/main/kotlin/com/opendatamask/domain/port/input/dto/CustomDataMappingDto.kt	Exposes `piiRuleParams` on mapping request/response DTOs.
backend/src/test/kotlin/com/opendatamask/domain/model/PIIMaskingRuleTest.kt	Adds unit tests for built-in rule behavior and ruleId stability.
backend/src/test/kotlin/com/opendatamask/application/service/DefaultRuleRegistryTest.kt	Tests built-in rule availability and custom rule registration/override.
backend/src/test/kotlin/com/opendatamask/application/service/PIIMaskingServiceTest.kt	Tests applying mappings across strategies and edge cases.
backend/src/test/kotlin/com/opendatamask/application/service/JobServiceTest.kt	Updates JobService tests to mock `PIIMaskingService` behavior.

Comments suppressed due to low confidence (1)

docs/user-guide.md:740

The ## Contributing section header was removed, but the contributing steps still appear immediately after the PII mapping section. Re-add a ## Contributing heading (or otherwise separate these sections) so the document structure/table-of-contents is correct.


## Contributing

1. Fork the repository
2. Create a feature branch: `git checkout -b feature/my-feature`

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2026-04-16T16:35:57Z

+    private fun parseParams(json: String?): Map<String, String> {
+        if (json.isNullOrBlank()) return emptyMap()
+        return runCatching { mapper.readValue<Map<String, String>>(json) }.getOrDefault(emptyMap())
+    }


parseParams() silently swallows JSON parse failures and returns an empty map. Combined with strategy defaults, this can cause unintended masking behavior without any visibility. Consider returning null on parse failure and either skipping the transformation for that column or emitting a warning log so operators can diagnose broken configurations.

Copilot · 2026-04-16T16:35:58Z

+        return when (mapping.maskingStrategy) {
+            MaskingStrategy.NULL -> null
+            MaskingStrategy.REDACT -> ruleRegistry.getRule("redact")?.mask(value) ?: "[REDACTED]"
+            MaskingStrategy.HASH -> {
+                val salt = params["salt"] ?: ""
+                HashRule(salt).mask(value)
+            }
+            MaskingStrategy.PARTIAL_MASK -> {
+                val keepFirst = params["keepFirst"]?.toIntOrNull() ?: 0
+                val keepLast = params["keepLast"]?.toIntOrNull() ?: 4
+                val maskChar = params["maskChar"]?.firstOrNull() ?: '*'
+                PartialMaskRule(keepFirst, keepLast, maskChar).mask(value)
+            }
+            MaskingStrategy.REGEX -> {
+                val pattern = params["pattern"] ?: ".*"
+                val replacement = params["replacement"] ?: ""
+                RegexRule(pattern, replacement).mask(value)
+            }
+            // FAKE strategy is handled upstream by the GeneratorService; return value unchanged.
+            MaskingStrategy.FAKE -> value
+            null -> value
+        }
+    }
+


applyStrategy() only consults RuleRegistryPort for REDACT; HASH/PARTIAL_MASK/REGEX are instantiated directly. This makes registerCustomRule() unusable for job-time mappings and contradicts the stated “registry pattern” approach. Consider using the registry for strategy dispatch (including custom rule IDs in piiRuleParams) or adjusting the design/docs so it’s clear which strategies are registry-driven.

Suggested change

return when (mapping.maskingStrategy) {

MaskingStrategy.NULL -> null

MaskingStrategy.REDACT -> ruleRegistry.getRule("redact")?.mask(value) ?: "[REDACTED]"

MaskingStrategy.HASH -> {

val salt = params["salt"] ?: ""

HashRule(salt).mask(value)

}

MaskingStrategy.PARTIAL_MASK -> {

val keepFirst = params["keepFirst"]?.toIntOrNull() ?: 0

val keepLast = params["keepLast"]?.toIntOrNull() ?: 4

val maskChar = params["maskChar"]?.firstOrNull() ?: '*'

PartialMaskRule(keepFirst, keepLast, maskChar).mask(value)

}

MaskingStrategy.REGEX -> {

val pattern = params["pattern"] ?: ".*"

val replacement = params["replacement"] ?: ""

RegexRule(pattern, replacement).mask(value)

}

// FAKE strategy is handled upstream by the GeneratorService; return value unchanged.

MaskingStrategy.FAKE -> value

null -> value

}

}

params["ruleId"]

?.takeIf { it.isNotBlank() }

?.let { ruleId ->

applyRegistryRule(ruleId, value)?.let { return it }

}

return when (mapping.maskingStrategy) {

MaskingStrategy.NULL -> null

MaskingStrategy.REDACT -> applyRegistryRule("redact", value) ?: "[REDACTED]"

MaskingStrategy.HASH -> applyRegistryRule("hash", value) ?: applyHashRule(params, value)

MaskingStrategy.PARTIAL_MASK -> applyRegistryRule("partial_mask", value) ?: applyPartialMaskRule(params, value)

MaskingStrategy.REGEX -> applyRegistryRule("regex", value) ?: applyRegexRule(params, value)

// FAKE strategy is handled upstream by the GeneratorService; return value unchanged.

MaskingStrategy.FAKE -> value

null -> value

}

}

private fun applyRegistryRule(ruleId: String, value: Any?): Any? =

ruleRegistry.getRule(ruleId)?.mask(value)

private fun applyHashRule(params: Map<String, String>, value: Any?): Any? {

val salt = params["salt"] ?: ""

return HashRule(salt).mask(value)

}

private fun applyPartialMaskRule(params: Map<String, String>, value: Any?): Any? {

val keepFirst = params["keepFirst"]?.toIntOrNull() ?: 0

val keepLast = params["keepLast"]?.toIntOrNull() ?: 4

val maskChar = params["maskChar"]?.firstOrNull() ?: '*'

return PartialMaskRule(keepFirst, keepLast, maskChar).mask(value)

}

private fun applyRegexRule(params: Map<String, String>, value: Any?): Any? {

val pattern = params["pattern"] ?: ".*"

val replacement = params["replacement"] ?: ""

return RegexRule(pattern, replacement).mask(value)

}

Copilot · 2026-04-16T16:35:58Z

+After registering the rule, invoke it programmatically via `PIIMaskingService.applyMappings()`, or create a standard mapping with any built-in strategy that routes through `PIIMaskingService`.
+


This paragraph describes configuring a runtime-registered custom rule via maskingStrategy: "REGEX" and piiRuleParams: {"ruleId": ...}. The current PIIMaskingService implementation does not read a ruleId param for REGEX (it always treats REGEX as a regex replacement), so this guidance won’t work as written. Either implement ruleId-based dispatch via RuleRegistryPort or update the docs to match the implemented behavior.

Copilot · 2026-04-16T16:35:58Z

+      "piiRuleParams": {
+        "keepFirst": "1",
+        "keepLast": "0",
+        "maskChar": "*"
+      },
+      "description": "Keeps only the first initial; e.g. 'Alice Smith' → 'A**********'"
+    },
+    {
+      "columnName": "email",
+      "action": "MASK",
+      "maskingStrategy": "REGEX",
+      "piiRuleParams": {
+        "pattern": "(\\w+)@(\\w+\\.\\w+)",
+        "replacement": "***@$2"
+      },


piiRuleParams is shown here as a JSON object, but the API/DTOs and frontend types define it as a JSON string (TEXT column persisted as String?). This sample file is likely not directly usable with the REST bulk mapping endpoint unless piiRuleParams is stringified/escaped (or the API is changed to accept structured JSON).

Suggested change

"piiRuleParams": {

"keepFirst": "1",

"keepLast": "0",

"maskChar": "*"

},

"description": "Keeps only the first initial; e.g. 'Alice Smith' → 'A**********'"

},

{

"columnName": "email",

"action": "MASK",

"maskingStrategy": "REGEX",

"piiRuleParams": {

"pattern": "(\\w+)@(\\w+\\.\\w+)",

"replacement": "***@$2"

},

"piiRuleParams": "{\"keepFirst\":\"1\",\"keepLast\":\"0\",\"maskChar\":\"*\"}",

"description": "Keeps only the first initial; e.g. 'Alice Smith' → 'A**********'"

},

{

"columnName": "email",

"action": "MASK",

"maskingStrategy": "REGEX",

"piiRuleParams": "{\"pattern\":\"(\\\\w+)@(\\\\w+\\\\.\\\\w+)\",\"replacement\":\"***@$2\"}",

Copilot · 2026-04-16T16:35:59Z

+            MaskingStrategy.REGEX -> {
+                val pattern = params["pattern"] ?: ".*"
+                val replacement = params["replacement"] ?: ""
+                RegexRule(pattern, replacement).mask(value)
+            }


REGEX defaults (pattern = ".*", replacement = "") mean that if piiRuleParams is missing/invalid, the value will be replaced by an empty string (effectively data loss). For safety, treat missing/invalid required params as a no-op (return the original value) or fail fast/log clearly instead of applying these destructive defaults.

Copilot · 2026-04-16T16:36:00Z

+    init {
+        register(PassThroughRule())
+        register(RedactRule())
+        register(PartialMaskRule())
+        register(HashRule())
+    }


DefaultRuleRegistry does not register a regex rule ID, even though RegexRule is modeled as a built-in rule (and docs/UI may expect discoverability via getAllRuleIds()). Either include regex in the registry (which likely requires changing the registry to handle parameterized rules) or document/rename the registry so it’s clearly only for non-parameterized/custom rules.

Copilot · 2026-04-16T16:36:00Z

@@ -11,7 +11,7 @@ Core capabilities:
 - **Privacy intelligence**: Automatic sensitive column detection, privacy hub dashboards, and compliance reports
 - **Job scheduling**: Cron-based automated masking runs
 - **Webhook integration**: Post-job notifications via custom HTTP webhooks or GitHub Actions triggers


The “Core capabilities” list replaced the existing “REST API + CLI” bullet with the new PII mapping bullet. This removes a still-supported capability from the guide; consider adding the PII mapping bullet without deleting the REST API/CLI bullet (or rewording so both are represented).

Suggested change

- **Webhook integration**: Post-job notifications via custom HTTP webhooks or GitHub Actions triggers

- **Webhook integration**: Post-job notifications via custom HTTP webhooks or GitHub Actions triggers

- **REST API + CLI**: Programmatic and command-line access for automation, integration, and workflow management

Copilot · 2026-04-16T16:36:00Z

+    fun `PartialMaskRule with short input returns input unchanged`() {
+        val rule = PartialMaskRule(keepFirst = 2, keepLast = 3)
+        assertEquals("hello", rule.mask("hello"))
+    }


This test declares val rule = PartialMaskRule(keepFirst = 2, keepLast = 3) but then asserts against a different PartialMaskRule(keepFirst = 0, keepLast = 10) instance, so it doesn't actually validate the behavior implied by the test name. Use the rule variable in the assertion (and consider adding a case where keepFirst + keepLast exceeds input length, which is a common edge case).

Copilot · 2026-04-16T16:36:00Z

+                    data.map { row ->
+                        piiMaskingService.applyMappings(workspaceId, sourceConnectionId, tableConfig.tableName, row)
+                    }


processTable() applies piiMaskingService.applyMappings(...) per row, but applyMappings() loads mappings from CustomDataMappingPort each call. In PASSTHROUGH mode this becomes a DB query per row (N+1) and will not scale for large tables. Load mappings once per table and apply them in-memory (e.g., add a service method that accepts a pre-fetched mapping map or returns a row-transform function).

Suggested change

data.map { row ->

piiMaskingService.applyMappings(workspaceId, sourceConnectionId, tableConfig.tableName, row)

}

piiMaskingService.applyMappingsToRows(

workspaceId,

sourceConnectionId,

tableConfig.tableName,

data

)

Copilot · 2026-04-16T16:36:01Z

+    // Apply all active CustomDataMappings for the given workspace/connection/table to a single row.
+    fun applyMappings(
+        workspaceId: Long,
+        connectionId: Long,
+        tableName: String,
+        row: Map<String, Any?>
+    ): Map<String, Any?> {
+        val mappings = customDataMappingPort
+            .findByWorkspaceIdAndConnectionIdAndTableName(workspaceId, connectionId, tableName)
+            .associateBy { it.columnName.lowercase() }
+


applyMappings() fetches mappings from persistence on every invocation. Given it is designed to be called per-row, this will create a query per row unless callers pre-batch. Consider changing the API to accept pre-fetched mappings (or adding an overload like applyMappings(mappings, row) / applyMappingsToRows(...)) so JobService can fetch once and reuse.

Suggested change

// Apply all active CustomDataMappings for the given workspace/connection/table to a single row.

fun applyMappings(

workspaceId: Long,

connectionId: Long,

tableName: String,

row: Map<String, Any?>

): Map<String, Any?> {

val mappings = customDataMappingPort

.findByWorkspaceIdAndConnectionIdAndTableName(workspaceId, connectionId, tableName)

.associateBy { it.columnName.lowercase() }

fun loadMappings(

workspaceId: Long,

connectionId: Long,

tableName: String

): Map<String, CustomDataMapping> =

customDataMappingPort

.findByWorkspaceIdAndConnectionIdAndTableName(workspaceId, connectionId, tableName)

.associateBy { it.columnName.lowercase() }

// Apply all active CustomDataMappings for the given workspace/connection/table to a single row.

fun applyMappings(

workspaceId: Long,

connectionId: Long,

tableName: String,

row: Map<String, Any?>

): Map<String, Any?> =

applyMappings(loadMappings(workspaceId, connectionId, tableName), row)

// Apply pre-fetched CustomDataMappings to a single row to avoid repeated persistence lookups.

fun applyMappings(

mappings: Map<String, CustomDataMapping>,

row: Map<String, Any?>

): Map<String, Any?> {

MaximumTrainer · 2026-04-16T16:38:14Z

@copilot apply changes based on the comments in this thread

… negative param guards, invalid regex handling, docs/sample JSON corrections Agent-Logs-Url: https://github.com/MaximumTrainer/OpenDataMask/sessions/2767f87d-a0e1-4191-8b45-6d3cfc40f59a Co-authored-by: MaximumTrainer <1376575+MaximumTrainer@users.noreply.github.com>

Agent-Logs-Url: https://github.com/MaximumTrainer/OpenDataMask/sessions/2767f87d-a0e1-4191-8b45-6d3cfc40f59a Co-authored-by: MaximumTrainer <1376575+MaximumTrainer@users.noreply.github.com>

Copilot · 2026-04-16T16:51:24Z

@copilot apply changes based on the comments in this thread

All review comments have been addressed in commit 80d4e02. Here's a summary of what changed:

N+1 fix: Added applyMappingsToRows() batch API that fetches mappings once per table; JobService.processTable now uses this instead of a per-row call.
Registry dispatch: ruleId key in piiRuleParams is now checked first — if set, the engine delegates to RuleRegistryPort.getRule() before falling back to the built-in strategy logic. Unknown rule IDs log a warning and pass the value through unchanged.
Safe REGEX defaults: Missing/blank pattern or replacement is now a no-op with a warning log (not the previous destructive ".*" / "" defaults).
Invalid JSON passthrough: parseParams() now returns null + logs a warning on parse failure, causing applyStrategy() to pass the value through unchanged.
Negative param guards: PartialMaskRule now applies coerceAtLeast(0) to keepFirst/keepLast.
RegexRule validation: Pattern is validated at construction with runCatching; error message identifies the invalid pattern.
DefaultRuleRegistry: Updated comment explaining why RegexRule is not registered as a zero-arg default (it's parameterized; PIIMaskingService constructs instances from piiRuleParams directly).
Sample JSON: piiRuleParams values corrected from nested objects to JSON strings (matching the String? API contract).
User guide: Restored the "REST API + CLI" bullet; updated custom rule registration section to show the ruleId-in-piiRuleParams dispatch pattern with a concrete API example.

Warning

Firewall rules blocked me from connecting to one or more addresses (expand for details)

I tried to connect to the following addresses, but was blocked by firewall rules:

example.com
- Triggering command: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java /usr/lib/jvm/temurin-17-jdk-amd64/bin/java -Dorg.gradle.internal.worker.tmpdir=/home/REDACTED/work/OpenDataMask/OpenDataMask/backend/build/tmp/test/work -Dorg.gradle.native=false -javaagent:/home/REDACTED/work/OpenDataMask/OpenDataMask/backend/build/tmp/.cache/expanded/zip_0bd0851504e6286cb5fc6f37a81e25cc/jacocoagent.jar=destfile=build/jacoco/test.exec,append=true,inclnolocationclasses=false,dumponexit=true,output=file,jmx=false @/home/REDACTED/.gradle/.tmp/gradle-worker-classpath6709998621720523581txt -Xmx512m -Dfile.encoding=UTF-8 -Duser.country -Duser.language=en -Duser.variant -ea worker.org.gradle.process.internal.worker.GradleWorkerMain 'Gradle Test Executor 2' (dns block)
- Triggering command: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java /usr/lib/jvm/temurin-17-jdk-amd64/bin/java -Dorg.gradle.internal.worker.tmpdir=/home/REDACTED/work/OpenDataMask/OpenDataMask/backend/build/tmp/test/work -Dorg.gradle.native=false -javaagent:/home/REDACTED/work/OpenDataMask/OpenDataMask/backend/build/tmp/.cache/expanded/zip_0bd0851504e6286cb5fc6f37a81e25cc/jacocoagent.jar=destfile=build/jacoco/test.exec,append=true,inclnolocationclasses=false,dumponexit=true,output=file,jmx=false @/home/REDACTED/.gradle/.tmp/gradle-worker-classpath16868345120307353527txt -Xmx512m -Dfile.encoding=UTF-8 -Duser.country -Duser.language=en -Duser.variant -ea worker.org.gradle.process.internal.worker.GradleWorkerMain 'Gradle Test Executor 3' (dns block)

If you need me to access, download, or install something from one of these locations, you can either:

Configure Actions setup steps to set up my environment, which run before the firewall is enabled
Add the appropriate URLs or hosts to the custom allowlist in this repository's Copilot coding agent settings (admins only)

MaximumTrainer · 2026-04-16T16:55:29Z

@copilot investigate failing frontend test

…→6 values) Agent-Logs-Url: https://github.com/MaximumTrainer/OpenDataMask/sessions/d8d4e537-ec28-43cf-9833-c5878af52d50 Co-authored-by: MaximumTrainer <1376575+MaximumTrainer@users.noreply.github.com>

Copilot · 2026-04-16T16:57:55Z

@copilot investigate failing frontend test

The failing test was DataMappingView.test.ts — it asserted MaskingStrategy had exactly 3 values, but the PR added REDACT, PARTIAL_MASK, and REGEX, bringing the count to 6. Fixed in commit 174a8f5 by updating the assertion to 6 and adding a companion test that covers the three new values. All 25 frontend tests now pass.

Initial plan

afdb3a1

Copilot AI assigned Copilot and MaximumTrainer Apr 16, 2026

Copilot started work on behalf of MaximumTrainer April 16, 2026 16:08 View session

Copilot AI linked an issue Apr 16, 2026 that may be closed by this pull request

add the ability for users to select & create custom PII attribute rules for source data going to target #62

Closed

MaximumTrainer requested a review from Copilot April 16, 2026 16:29

Copilot started reviewing on behalf of MaximumTrainer April 16, 2026 16:29 View session

Copilot AI changed the title ~~[WIP] Add ability for users to select and create custom PII attribute rules~~ feat: PII attribute rule mapping system with extensible rule registry Apr 16, 2026

Copilot finished work on behalf of MaximumTrainer April 16, 2026 16:31

Copilot AI requested a review from MaximumTrainer April 16, 2026 16:31

Copilot AI reviewed Apr 16, 2026

View reviewed changes

Copilot started work on behalf of MaximumTrainer April 16, 2026 16:38 View session

Copilot AI and others added 2 commits April 16, 2026 16:47

fix: minor style improvements from second validation pass

80d4e02

Agent-Logs-Url: https://github.com/MaximumTrainer/OpenDataMask/sessions/2767f87d-a0e1-4191-8b45-6d3cfc40f59a Co-authored-by: MaximumTrainer <1376575+MaximumTrainer@users.noreply.github.com>

Copilot finished work on behalf of MaximumTrainer April 16, 2026 16:53

MaximumTrainer marked this pull request as ready for review April 16, 2026 16:54

Copilot started work on behalf of MaximumTrainer April 16, 2026 16:55 View session

fix: update DataMappingView test for expanded MaskingStrategy enum (3…

174a8f5

…→6 values) Agent-Logs-Url: https://github.com/MaximumTrainer/OpenDataMask/sessions/d8d4e537-ec28-43cf-9833-c5878af52d50 Co-authored-by: MaximumTrainer <1376575+MaximumTrainer@users.noreply.github.com>

MaximumTrainer merged commit cfb004d into main Apr 16, 2026

MaximumTrainer deleted the copilot/add-custom-pii-attribute-rules branch April 16, 2026 16:58

Copilot stopped work on behalf of MaximumTrainer due to an error April 16, 2026 16:59
The session was cancelled by the user.

This was referenced Apr 16, 2026

Implement Dynamic Attribute Discovery and Persistent Rule Storage for OpenDataMask #57

Closed

add ability for custom PII attribute masking #49

Closed

		After registering the rule, invoke it programmatically via `PIIMaskingService.applyMappings()`, or create a standard mapping with any built-in strategy that routes through `PIIMaskingService`.

	- Webhook integration: Post-job notifications via custom HTTP webhooks or GitHub Actions triggers
	- Webhook integration: Post-job notifications via custom HTTP webhooks or GitHub Actions triggers
	- REST API + CLI: Programmatic and command-line access for automation, integration, and workflow management

Conversation

Copilot AI commented Apr 16, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Copilot AI Apr 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 16, 2026

Choose a reason for hiding this comment

Uh oh!

MaximumTrainer commented Apr 16, 2026

Uh oh!

Copilot AI commented Apr 16, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

I tried to connect to the following addresses, but was blocked by firewall rules:

Uh oh!

MaximumTrainer commented Apr 16, 2026

Uh oh!

Copilot AI commented Apr 16, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

Copilot AI commented Apr 16, 2026 •

edited

Loading

Copilot AI commented Apr 16, 2026 •

edited

Loading