claude-dev-env 8.83.1 → 8.83.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.83.1",
+    "version": "8.83.2",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

package/scripts/Sync-RepoMain.ps1

@@ -189,6 +189,35 @@ function Invoke-AdoptCopiedTree {
     return $false
 }
 
+function Get-RunLockName {
+    $lockPath = [System.IO.Path]::TrimEndingDirectorySeparator([System.IO.Path]::GetFullPath($RepoPath))
+    $resolveLinkTarget = [System.IO.Directory].GetMethod('ResolveLinkTarget', [type[]]([string], [bool]))
+    if ((Test-Path -LiteralPath $lockPath) -and ($null -ne $resolveLinkTarget)) {
+        $finalTarget = [System.IO.Directory]::ResolveLinkTarget($lockPath, $true)
+        if ($null -ne $finalTarget) {
+            $lockPath = [System.IO.Path]::TrimEndingDirectorySeparator($finalTarget.FullName)
+        }
+    }
+    $pathBytes = [System.Text.Encoding]::UTF8.GetBytes($lockPath.ToLowerInvariant())
+    $pathHash = [System.Convert]::ToHexString([System.Security.Cryptography.SHA256]::HashData($pathBytes))
+    return "Global\SyncRepoMain-$pathHash"
+}
+
+$runLock = [System.Threading.Mutex]::new($false, (Get-RunLockName))
+try {
+    $hasRunLock = $runLock.WaitOne(0)
+}
+catch [System.Threading.AbandonedMutexException] {
+    $hasRunLock = $true
+}
+if (-not $hasRunLock) {
+    Write-SyncLog -Level 'SKIP' -Message "another sync of $RepoPath is still running"
+    exit 3
+}
+
+$env:GIT_TERMINAL_PROMPT = '0'
+$env:GCM_INTERACTIVE = 'never'
+
 try {
     if (-not (Test-Path -LiteralPath $RepoPath)) {
         Write-SyncLog -Level 'ERROR' -Message "repo path missing: $RepoPath"
@@ -212,7 +241,7 @@ try {
         exit 3
     }
 
-    $null = Invoke-GitOrExit -Arguments @('fetch', $Remote, $Branch) `
+    $null = Invoke-GitOrExit -Arguments @('-c', 'http.lowSpeedLimit=1000', '-c', 'http.lowSpeedTime=60', 'fetch', $Remote, $Branch) `
         -FailureMessage "fetch $Remote $Branch failed" -FailureExitCode 1
 
     $tipOutput = Invoke-GitOrExit -Arguments @('rev-parse', $Branch, "$Remote/$Branch") `

package/scripts/tests/Sync-RepoMain.Tests.ps1

@@ -105,4 +105,29 @@ Describe 'Sync-RepoMain' {
         [System.IO.File]::ReadAllText((Join-Path $fixture.MirrorPath 'added.txt')) | Should -Be "local only`n"
         [System.IO.File]::ReadAllText((Join-Path $fixture.MirrorPath 'tracked.txt')) | Should -Be "new`n"
     }
+
+    It 'skips without fetching while another sync of the same repo holds the run lock' {
+        $fixture = New-MirrorBehindRemote -Name 'lock-held'
+        $lockPath = [System.IO.Path]::TrimEndingDirectorySeparator([System.IO.Path]::GetFullPath($fixture.MirrorPath))
+        $pathBytes = [System.Text.Encoding]::UTF8.GetBytes($lockPath.ToLowerInvariant())
+        $lockName = 'Global\SyncRepoMain-' + [System.Convert]::ToHexString([System.Security.Cryptography.SHA256]::HashData($pathBytes))
+        $readyPath = Join-Path $TestDrive 'lock-ready'
+        $holderCommand = "`$lock = [System.Threading.Mutex]::new(`$true, '$lockName'); Set-Content -LiteralPath '$readyPath' -Value ready; Start-Sleep -Seconds 30"
+        $holder = Start-Process pwsh -ArgumentList '-NoProfile', '-Command', $holderCommand -PassThru
+        try {
+            $deadline = (Get-Date).AddSeconds(20)
+            while (-not (Test-Path -LiteralPath $readyPath) -and (Get-Date) -lt $deadline) {
+                Start-Sleep -Milliseconds 200
+            }
+
+            $exitCode = Invoke-SyncScript -Fixture $fixture
+        }
+        finally {
+            Stop-Process -Id $holder.Id -Force -ErrorAction SilentlyContinue
+        }
+
+        $exitCode | Should -Be 3
+        (Invoke-TestGit -RepoPath $fixture.MirrorPath -Arguments @('rev-parse', 'HEAD')) | Should -Be $fixture.OldTip
+        (Get-Content -LiteralPath $fixture.LogPath -Raw) | Should -Match 'still running'
+    }
 }

package/scripts/tests/test_sync_repo_main_run_lock.py

@@ -0,0 +1,168 @@
+"""Specifications for Sync-RepoMain skipping while another run of the same repo is live."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import shutil
+import subprocess
+import time
+from pathlib import Path
+
+_SCRIPT_PATH = Path(__file__).resolve().parents[1] / "Sync-RepoMain.ps1"
+_PWSH = shutil.which("pwsh") or "pwsh"
+_SKIPPED_EXIT_CODE = 3
+_SUCCESS_EXIT_CODE = 0
+_LOCK_READY_TIMEOUT_SECONDS = 20
+
+
+def _git(repository_path: Path, *arguments: str) -> str:
+    completed = subprocess.run(
+        [
+            "git",
+            "-C",
+            str(repository_path),
+            "-c",
+            "user.name=tester",
+            "-c",
+            "user.email=tester@example.com",
+            *arguments,
+        ],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return completed.stdout.strip()
+
+
+def _mirror_one_commit_behind(root_path: Path) -> Path:
+    remote_path = root_path / "remote.git"
+    author_path = root_path / "author"
+    mirror_path = root_path / "mirror"
+    remote_path.mkdir()
+    author_path.mkdir()
+    _git(remote_path, "init", "-q", "--bare", "-b", "main")
+    _git(author_path, "init", "-q", "-b", "main")
+    (author_path / "tracked.txt").write_text("old\n", encoding="utf-8")
+    _git(author_path, "add", "-A")
+    _git(author_path, "commit", "-q", "-m", "first")
+    _git(author_path, "remote", "add", "origin", str(remote_path))
+    _git(author_path, "push", "-q", "origin", "main")
+    subprocess.run(
+        ["git", "clone", "-q", str(remote_path), str(mirror_path)], check=True
+    )
+    (author_path / "tracked.txt").write_text("new\n", encoding="utf-8")
+    _git(author_path, "commit", "-q", "-am", "second")
+    _git(author_path, "push", "-q", "origin", "main")
+    return mirror_path
+
+
+def _run_lock_name(mirror_path: Path) -> str:
+    normalized_path = os.path.normpath(str(mirror_path)).lower()
+    path_digest = hashlib.sha256(normalized_path.encode("utf-8")).hexdigest().upper()
+    return f"Global\\SyncRepoMain-{path_digest}"
+
+
+def _run_sync(mirror_path: Path, log_path: Path, repo_path: str | None = None) -> int:
+    argument_path = str(mirror_path) if repo_path is None else repo_path
+    completed = subprocess.run(
+        [
+            _PWSH,
+            "-NoProfile",
+            "-File",
+            str(_SCRIPT_PATH),
+            "-RepoPath",
+            argument_path,
+            "-LogPath",
+            str(log_path),
+        ],
+        capture_output=True,
+        text=True,
+    )
+    return completed.returncode
+
+
+def test_should_skip_without_fetching_while_another_run_holds_the_lock(
+    tmp_path: Path,
+) -> None:
+    mirror_path = _mirror_one_commit_behind(tmp_path)
+    old_tip = _git(mirror_path, "rev-parse", "HEAD")
+    log_path = tmp_path / "sync.log"
+    ready_path = tmp_path / "lock-ready"
+    holder_command = (
+        f"$lock = [System.Threading.Mutex]::new($true, '{_run_lock_name(mirror_path)}'); "
+        f"Set-Content -LiteralPath '{ready_path}' -Value ready; Start-Sleep -Seconds 30"
+    )
+    holder = subprocess.Popen([_PWSH, "-NoProfile", "-Command", holder_command])
+    try:
+        deadline = time.monotonic() + _LOCK_READY_TIMEOUT_SECONDS
+        while not ready_path.exists() and time.monotonic() < deadline:
+            time.sleep(0.2)
+        held_exit_code = _run_sync(mirror_path, log_path)
+    finally:
+        holder.kill()
+        holder.wait()
+
+    assert held_exit_code == _SKIPPED_EXIT_CODE
+    assert _git(mirror_path, "rev-parse", "HEAD") == old_tip
+    assert "still running" in log_path.read_text(encoding="utf-8")
+
+    assert _run_sync(mirror_path, log_path) == _SUCCESS_EXIT_CODE
+    assert _git(mirror_path, "rev-parse", "HEAD") != old_tip
+
+
+def test_should_skip_a_second_spelling_of_the_same_repo(tmp_path: Path) -> None:
+    mirror_path = _mirror_one_commit_behind(tmp_path)
+    old_tip = _git(mirror_path, "rev-parse", "HEAD")
+    ready_path = tmp_path / "lock-ready"
+    holder_command = (
+        f"$lock = [System.Threading.Mutex]::new($true, '{_run_lock_name(mirror_path)}'); "
+        f"Set-Content -LiteralPath '{ready_path}' -Value ready; Start-Sleep -Seconds 30"
+    )
+    holder = subprocess.Popen([_PWSH, "-NoProfile", "-Command", holder_command])
+    try:
+        deadline = time.monotonic() + _LOCK_READY_TIMEOUT_SECONDS
+        while not ready_path.exists() and time.monotonic() < deadline:
+            time.sleep(0.2)
+        assert ready_path.exists()
+        spellings = (
+            f"{mirror_path}{os.sep}",
+            os.path.join(str(mirror_path), "."),
+        )
+        for spelling in spellings:
+            spelling_log = tmp_path / "spelling.log"
+            spelling_log.unlink(missing_ok=True)
+            exit_code = _run_sync(mirror_path, spelling_log, repo_path=spelling)
+            assert exit_code == _SKIPPED_EXIT_CODE
+            assert _git(mirror_path, "rev-parse", "HEAD") == old_tip
+            assert "still running" in spelling_log.read_text(encoding="utf-8")
+    finally:
+        holder.kill()
+        holder.wait()
+
+
+def test_should_skip_when_the_repo_path_is_a_symlink(tmp_path: Path) -> None:
+    mirror_path = _mirror_one_commit_behind(tmp_path)
+    old_tip = _git(mirror_path, "rev-parse", "HEAD")
+    link_path = tmp_path / "mirror-link"
+    os.symlink(mirror_path, link_path, target_is_directory=True)
+    log_path = tmp_path / "sync.log"
+    ready_path = tmp_path / "lock-ready"
+    holder_command = (
+        f"$lock = [System.Threading.Mutex]::new($true, '{_run_lock_name(mirror_path)}'); "
+        f"Set-Content -LiteralPath '{ready_path}' -Value ready; Start-Sleep -Seconds 30"
+    )
+    holder = subprocess.Popen([_PWSH, "-NoProfile", "-Command", holder_command])
+    try:
+        deadline = time.monotonic() + _LOCK_READY_TIMEOUT_SECONDS
+        while not ready_path.exists() and time.monotonic() < deadline:
+            time.sleep(0.2)
+        assert ready_path.exists()
+        exit_code = _run_sync(mirror_path, log_path, repo_path=str(link_path))
+    finally:
+        holder.kill()
+        holder.wait()
+
+    assert exit_code == _SKIPPED_EXIT_CODE
+    assert _git(mirror_path, "rev-parse", "HEAD") == old_tip
+    assert "still running" in log_path.read_text(encoding="utf-8")