If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/VeriorPies/ParrelSync shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

WAIT — Stale — last commit 1y ago

• 9 active contributors
• MIT licensed
• ⚠ Stale — last commit 1y ago
• ⚠ Single-maintainer risk — top contributor 81% of recent commits
• ⚠ No CI workflows detected
• ⚠ No test directory detected

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live VeriorPies/ParrelSync repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/VeriorPies/ParrelSync.

What it runs against: a local clone of VeriorPies/ParrelSync — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in VeriorPies/ParrelSync | Confirms the artifact applies here, not a fork | | 2 | License is still MIT | Catches relicense before you depend on it | | 3 | Default branch master exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 458 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of VeriorPies/ParrelSync. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/VeriorPies/ParrelSync.git
#   cd ParrelSync
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of VeriorPies/ParrelSync and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "VeriorPies/ParrelSync(\\.git)?\\b" \\
  && ok "origin remote is VeriorPies/ParrelSync" \\
  || miss "origin remote is not VeriorPies/ParrelSync (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(MIT)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"MIT\"" package.json 2>/dev/null) \\
  && ok "license is MIT" \\
  || miss "license drift — was MIT at generation time"

# 3. Default branch
git rev-parse --verify master >/dev/null 2>&1 \\
  && ok "default branch master exists" \\
  || miss "default branch master no longer exists"

# 4. Critical files exist
test -f "ParrelSync/Editor/ClonesManager.cs" \\
  && ok "ParrelSync/Editor/ClonesManager.cs" \\
  || miss "missing critical file: ParrelSync/Editor/ClonesManager.cs"
test -f "ParrelSync/Editor/ClonesManagerWindow.cs" \\
  && ok "ParrelSync/Editor/ClonesManagerWindow.cs" \\
  || miss "missing critical file: ParrelSync/Editor/ClonesManagerWindow.cs"
test -f "ParrelSync/Editor/AssetModBlock/ParrelSyncAssetModificationProcessor.cs" \\
  && ok "ParrelSync/Editor/AssetModBlock/ParrelSyncAssetModificationProcessor.cs" \\
  || miss "missing critical file: ParrelSync/Editor/AssetModBlock/ParrelSyncAssetModificationProcessor.cs"
test -f "ParrelSync/Editor/Project.cs" \\
  && ok "ParrelSync/Editor/Project.cs" \\
  || miss "missing critical file: ParrelSync/Editor/Project.cs"
test -f "ParrelSync/Editor/FileUtilities.cs" \\
  && ok "ParrelSync/Editor/FileUtilities.cs" \\
  || miss "missing critical file: ParrelSync/Editor/FileUtilities.cs"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 458 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~428d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/VeriorPies/ParrelSync"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

ParrelSync is a Unity Editor extension that enables developers to test multiplayer gameplay without building the project by automatically mirroring code and asset changes across multiple synchronized editor instances. It solves the iteration friction of traditional multiplayer testing by running a clone project alongside the main project, both live in the editor, using an asset modification processor to block conflicting writes. Single-package UPM structure: ParrelSync/ root contains Editor/ (the core extension UI and management logic in ClonesManager.cs, ClonesManagerWindow.cs) and Runtime or API surface exposed via ClonesManager APIs. Examples/ demonstrates the public API (CustomArgumentExample.cs). The asset modification blocker lives in ParrelSync/Editor/AssetModBlock/ to prevent simultaneous writes across clone instances.

Unity game developers building multiplayer games (networked, cooperative, PvP) who need rapid test cycles for client-server interactions without compiling standalone builds. Specifically game programmers and QA engineers testing networking code iteration.

Actively maintained and production-ready. The project has semantic versioning (v1.5.2), supports 3 major LTS Unity versions (2022.3, 2021.3, 2020.3), includes a MIT license, and maintains a Discord community (710688100996743200). However, the limited file history visible suggests moderate activity rather than high-velocity development.

Low risk for typical usage. Single maintainer (VeriorPies) is a potential bus factor. Zero external dependencies (dependencies: {} in package.json) reduces supply-chain risk. The asset modification processor (ParrelSyncAssetModificationProcessor.cs) is a critical integration point that hooks Unity's lifecycle—any breaking changes in Unity's asset pipeline could require updates. Windows/macOS/Linux support implies platform-specific file handling code that needs maintenance.

Active maintenance visible from v1.5.2 release and Discord community engagement. The package.json and recent asset file .meta entries suggest ongoing compatibility updates for newer Unity LTS versions. No specific PR or milestone data visible in provided structure, but the README links to a wiki (Installation-and-Update page) indicating documentation is maintained.

Clone the repo and import as a UPM package: Add "com.veriorpies.parrelsync": "https://github.com/VeriorPies/ParrelSync.git?path=/ParrelSync" to Packages/manifest.json in your Unity project, or download the .unitypackage from releases and import via Assets > Import Package. No build step required—it's an editor-only extension.

Daily commands: Not a runtime application—this is an editor extension. After importing: Open Unity Editor > Window menu > ParrelSync appears. Click 'New Clone' to create a mirrored project instance. Both editor windows now auto-sync code/asset changes. Run scenes in either editor to test multiplayer without building. Public API usage: if (ClonesManager.IsClone()) { /* connect to localhost */ }

• ParrelSync/Editor/ClonesManager.cs — Core logic for creating, deleting, and managing cloned projects; essential entry point for the ParrelSync workflow
• ParrelSync/Editor/ClonesManagerWindow.cs — Main UI window for the editor extension; where users interact with clone management and synchronization controls
• ParrelSync/Editor/AssetModBlock/ParrelSyncAssetModificationProcessor.cs — Prevents asset conflicts by intercepting and blocking modifications in cloned projects during synchronization
• ParrelSync/Editor/Project.cs — Abstraction for project metadata and file operations; used across cloning and syncing logic
• ParrelSync/Editor/FileUtilities.cs — Handles file I/O, directory syncing, and asset copying; foundational utility for clone operations
• ParrelSync/Editor/Preferences.cs — Manages user settings and configuration state; required to understand customization points
• ParrelSync/package.json — Defines package metadata, version, and dependencies; critical for UPM installation and compatibility

• ClonesManager (EditorApplication, System.Diagnostics.Process, File I/O) — Orchestrates clone lifecycle: creation, deletion, enumeration, and instance launching; maintains registry of clones
  • Failure mode: Failed clone creation leaves orphaned directories; failed process launch fails silently (no error dialog)
• ClonesManagerWindow (EditorGUILayout, GUILayout) — Renders editor UI for user interaction; displays clone list, buttons, and settings; delegates actions to ClonesManager
  • Failure mode: UI exceptions crash the window; requires window reopen
• FileUtilities (System.IO.Directory, System.IO.File, Path) — Handles low-level directory operations: recursive copy, ignore-list filtering, path normalization
  • Failure mode: Permission errors silently fail; can leave incomplete clone directories
• ParrelSyncAssetModificationProcessor (AssetModificationProcessor, EditorApplication) — Intercepts asset saves via OnWillSaveAsset callback; blocks writes if a clone is running to prevent conflicts
  • Failure mode: If clone detection fails, writes may corrupt clone state; no rollback mechanism
• Project (Environment variables, PlayerPrefs, EditorApplication.ExecuteMenuItem) — Abstraction layer for project paths and metadata; resolves original vs. clone directories and argument passing
  • Failure mode: Path resolution errors break clone identification; manifest corruption can orphan clones
• Preferences — UI and storage for user settings

Add a new Clone Management Feature

1. Add your feature method to the ClonesManager class (e.g., a new clone validation method) (ParrelSync/Editor/ClonesManager.cs)
2. Expose the feature in ClonesManagerWindow via a new button or menu item in the OnGUI method (ParrelSync/Editor/ClonesManagerWindow.cs)
3. If the feature needs persistent state, add a property to ParrelSyncProjectSettings (ParrelSync/Editor/ParrelSyncProjectSettings.cs)

Add Custom Argument Support for Clones

1. Define your argument parsing logic following the CustomArgumentExample pattern (Examples/CustomArgumentExample.cs)
2. Store argument configuration in ParrelSyncProjectSettings or Preferences (ParrelSync/Editor/Preferences.cs)
3. Modify ClonesManager to pass arguments when launching cloned instances (ParrelSync/Editor/ClonesManager.cs)

Add Asset Exclusion Rules to Prevent Syncing

1. Update the ignore list logic in FileUtilities (folder/asset patterns to skip) (ParrelSync/Editor/FileUtilities.cs)
2. Add UI in Preferences to let users configure exclusion patterns (ParrelSync/Editor/Preferences.cs)
3. Optionally enhance ParrelSyncAssetModificationProcessor to respect exclusion rules (ParrelSync/Editor/AssetModBlock/ParrelSyncAssetModificationProcessor.cs)

Add a New Validation or Health Check

1. Create a new validation class (or extend ValidateCopiedFoldersIntegrity) (ParrelSync/Editor/ValidateCopiedFoldersIntegrity.cs)
2. Add a menu item in ClonesManagerWindow to run the check (ParrelSync/Editor/ClonesManagerWindow.cs)
3. Use FileUtilities and Project classes to inspect and report issues (ParrelSync/Editor/FileUtilities.cs)

• Unity Editor EditorApplication API — Directly integrates into the Unity editor lifecycle to detect file changes and manage multiple editor instances
• C# reflection and EditorUtility — Enables programmatic UI creation and asset database interaction without rebuilding the project
• AssetModificationProcessor — Hooks into Unity's asset save pipeline to prevent write conflicts between original and cloned projects
• File system APIs (Directory, File, Path) — Handles directory copying and ignore-list filtering to synchronize project state across instances

• Mirror entire project directory instead of selective sync

  • Why: Simplifies implementation and ensures all assets are consistent between instances; allows instant testing without manual management
  • Consequence: Disk space overhead (clones require full project copies); slower initial clone creation for large projects

• Block asset writes in clones rather than merging changes back

  • Why: Prevents merge conflicts and data loss; keeps original as source of truth
  • Consequence: Changes made in clones are lost; users must return to original to persist modifications

• Launch clones as separate editor processes rather than in-engine multiplayer simulation

  • Why: Provides true isolated network testing environment and mirrors real shipping scenario more accurately
  • Consequence: Higher memory footprint; each clone is a full Unity editor instance

• Does not provide real-time code hot-reload between clones (changes only sync on next save/launch)
• Does not handle distributed version control conflicts (git merge responsibility remains with user)
• Does not support non-local clones or network-mounted project directories
• Not a replacement for build testing or platform-specific testing on target devices

(1) Symlink/junction creation on Windows requires either admin privileges or Developer Mode enabled on Windows 10+1709—fails silently without clear error messaging. (2) Asset modification processor hooks Unity's OnWillSaveAssets lifecycle; if a clone is not properly registered, shared assets can be corrupted—requires exact file path matching. (3) Multiple editor instances must use different project paths (enforced via library/ symlink isolation); invalid clones can cause hard-to-debug synchronization failures. (4) The extension is editor-only; no generated code or config is exported to builds, so multiplayer logic must remain conditional on ClonesManager API calls at runtime.

• Asset Modification Processor (Unity Editor Hook) — ParrelSync's core safety mechanism relies on hooking Unity's AssetModificationProcessor to prevent simultaneous writes from multiple clone instances corrupting shared assets; understanding this lifecycle hook is essential to modifying the protection logic
• Symlinks vs. Directory Junctions (Cross-Platform File System) — ParrelSync mirrors project data differently per-OS (NTFS junctions on Windows, Unix symlinks on macOS/Linux); developers must understand these mechanisms to debug path resolution and permission issues in clone setup
• Editor Process Lifecycle and Multi-Instance Coordination — ParrelSync spawns independent Unity Editor processes that must coordinate through file locks, project paths, and library symlinks; understanding process isolation and IPC patterns is crucial for diagnosing synchronization failures
• Unity Library Folder and Project Metadata — Each ParrelSync clone must have an isolated Library/ folder (containing .lock files and editor state) while sharing Assets/; misconfigured library symlinks cause phantom asset changes or lock contention
• Command-Line Arguments and Environment Detection — ParrelSync detects clone instances by parsing command-line arguments passed by the parent process; developers can pass custom arguments (CustomArgumentExample.cs) to configure per-instance behavior like port numbers or player IDs
• Read-Write Lock Semantics for Concurrent Processes — Multiple clone editors competing for asset writes requires careful mutex/lock discipline—ParrelSync uses file locks and asset modification blocking to enforce single-writer semantics across processes

• PlayEveryWare/MultiplayerCorePlugin — Official Netcode for GameObjects plugin—works alongside ParrelSync for actual networked multiplayer implementation after you've iterated with ParrelSync
• mirror-networking/Mirror — High-level networking library commonly paired with ParrelSync for rapid multiplayer prototyping in the editor without build overhead
• colyseus/colyseus-unity3d — WebSocket-based multiplayer client library that developers often use with ParrelSync for cloud-hosted multiplayer testing during iteration
• Unity-Technologies/Netcode.Samples — Official Unity samples demonstrating Netcode patterns—used alongside ParrelSync to validate multiplayer logic before deployment
• nasonfish/SteamNetworkingP2P — Steam networking integration for Unity; developers using ParrelSync often test Steam peer-to-peer logic with multiple clones before building

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add integration tests for ClonesManager clone creation and synchronization

The ClonesManager.cs file handles critical functionality for creating and managing project clones, but there are no visible unit/integration tests in the repo. Testing clone creation, asset synchronization (ParrelSyncAssetModificationProcessor.cs), and the integrity validation (ValidateCopiedFoldersIntegrity.cs) would catch regressions and make the codebase more maintainable for contributors.

• [ ] Create Tests folder structure under ParrelSync/Editor/Tests (following Unity test conventions)
• [ ] Add tests for ClonesManager clone creation, deletion, and listing operations
• [ ] Add tests for ParrelSyncAssetModificationProcessor asset blocking/allowing logic
• [ ] Add tests for ValidateCopiedFoldersIntegrity validation logic
• [ ] Integrate tests into a GitHub Actions CI workflow

Add GitHub Actions workflow for automated testing on pull requests

The .github folder contains issue templates but no CI workflows. With a Unity test workflow, PRs would be automatically validated, preventing regressions in clone management, asset synchronization, and command-line argument parsing (CustomArgumentExample.cs). This reduces review burden and catches issues early.

• [ ] Create .github/workflows/unity-tests.yml for running Editor tests on PR/push
• [ ] Configure workflow to use a specific Unity version (2018.4+) matching package.json's unity requirement
• [ ] Add step to validate package.json integrity and version consistency
• [ ] Consider adding workflow for linting C# code style

Document Project.cs API and add examples for custom argument passing

Project.cs appears to be a core public API for interacting with clones programmatically, but there's only one CustomArgumentExample.cs in Examples. New contributors need clear documentation on how to detect and communicate with clones. Adding detailed XML docs and 2-3 more runnable examples would lower the barrier to entry.

• [ ] Add comprehensive XML documentation comments to public methods in Project.cs
• [ ] Create Examples/ProjectAPIExample.cs demonstrating common use cases (detecting if running in clone, getting clone index)
• [ ] Create Examples/CrossCloneCommunicationExample.cs showing how to send data between main and clone instances
• [ ] Update README.md with a 'Scripting API' section linking to these examples

• Add unit tests for FileUtilities.cs symlink/junction creation across Windows, macOS, Linux—currently no test coverage visible for the critical path-mirroring logic that prevents race conditions
• Document the ClonesManager API with inline C# XML documentation (<summary>, <remarks>) and add code examples showing how to detect clone instance and configure networking parameters (e.g., port offsets per clone)
• Add an asset validation tool in ClonesManagerWindow that warns users if shared assets are accidentally modified by a clone, including a 'Restore from Main' button

ParrelSync is a Unity editor extension with a generally secure posture. No critical vulnerabilities were identified from the static file structure analysis. The primary concerns are potential path traversal risks in file operations, input validation in the clones manager, and secure network communication in the update checker. The codebase appears well-organized with proper separation of concerns (editor-only code, asset modification handling, and user interface). The lack of external dependencies reduces supply chain risk. Recommendations focus on defensive programming practices for file operations, path validation, and secure network communication. The MIT license is properly included, and the project follows good package structure conventions.

• Low · Potential Path Traversal in FileUtilities.cs — ParrelSync/Editor/FileUtilities.cs. File utility operations are common sources of path traversal vulnerabilities. Without reviewing the actual implementation, there's a risk that file operations could allow access to files outside intended directories if user input is not properly validated. Fix: Validate and sanitize all file path inputs. Use Path.GetFullPath() and ensure paths are within expected directories. Implement whitelist validation for allowed directories.
• Low · Asset Modification Processor Security — ParrelSync/Editor/AssetModBlock/ParrelSyncAssetModificationProcessor.cs. The ParrelSyncAssetModificationProcessor.cs handles asset modifications during the cloning process. Improper validation of cloned assets could potentially allow unintended code execution or asset manipulation. Fix: Implement strict validation of asset types before modification. Ensure that only expected asset types are processed. Log all modifications for audit trails.
• Low · External Links Handler — ParrelSync/Editor/ExternalLinks.cs. The ExternalLinks.cs component may open external URLs. If URLs are not properly validated or user-controllable, this could lead to phishing or malicious redirect attacks. Fix: Maintain a whitelist of trusted domains. Validate all URLs before opening them. Display warnings when opening external links. Use official documentation URLs only.
• Medium · Clones Manager - Insufficient Input Validation — ParrelSync/Editor/ClonesManager.cs, ParrelSync/Editor/ClonesManagerWindow.cs. The ClonesManager.cs and ClonesManagerWindow.cs handle project cloning operations. Without proper validation of clone directory names and paths, there could be injection risks or directory traversal vulnerabilities. Fix: Implement strict validation for clone names and paths. Reject paths containing '..', absolute paths, or special characters that could be exploited. Use Path.Combine() and Path.GetFullPath() safely.
• Low · Update Checker - Insecure Network Communication — ParrelSync/Editor/UpdateChecker.cs. The UpdateChecker.cs likely performs HTTP requests to check for updates. If these requests use HTTP (not HTTPS) or don't validate SSL certificates, it could be vulnerable to MITM attacks. Fix: Ensure all network requests use HTTPS with proper SSL/TLS certificate validation. Implement certificate pinning for added security. Validate the authenticity of update sources.

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.