wehub-resource-sync
817 lines
30 KiB
C#
817 lines
30 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net.Http;
|
|
using System.Security.Cryptography;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
|
|
namespace MCPForUnity.Editor.Setup
|
|
{
|
|
public static class SkillSyncService
|
|
{
|
|
private const string DefaultRepoUrl = "https://github.com/CoplayDev/unity-mcp";
|
|
private const string SkillSubdir = ".claude/skills/unity-mcp-skill";
|
|
private const string SyncOwnershipMarker = ".unity-mcp-skill-sync";
|
|
private const string LastSyncedCommitKeyPrefix = "UnityMcpSkillSync.LastSyncedCommit";
|
|
|
|
public sealed class SyncResult
|
|
{
|
|
public bool Success { get; set; }
|
|
public int Added { get; set; }
|
|
public int Updated { get; set; }
|
|
public int Deleted { get; set; }
|
|
public string CommitSha { get; set; }
|
|
public string Error { get; set; }
|
|
}
|
|
|
|
public static void SyncAsync(string installDir, string branch, Action<string> log, Action<SyncResult> onComplete)
|
|
{
|
|
SyncAsync(DefaultRepoUrl, installDir, branch, log, onComplete);
|
|
}
|
|
|
|
public static void SyncAsync(string repoUrl, string installDir, string branch, Action<string> log, Action<SyncResult> onComplete)
|
|
{
|
|
var lastSyncedCommitKey = GetLastSyncedCommitKey(repoUrl, branch);
|
|
var lastSyncedCommit = EditorPrefs.GetString(lastSyncedCommitKey, string.Empty);
|
|
|
|
Task.Run(() =>
|
|
{
|
|
try
|
|
{
|
|
var result = RunSync(repoUrl, installDir, branch, lastSyncedCommit, log);
|
|
EditorApplication.delayCall += () =>
|
|
{
|
|
if (result.Success && !string.IsNullOrEmpty(result.CommitSha))
|
|
{
|
|
EditorPrefs.SetString(lastSyncedCommitKey, result.CommitSha);
|
|
}
|
|
onComplete?.Invoke(result);
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
EditorApplication.delayCall += () =>
|
|
{
|
|
onComplete?.Invoke(new SyncResult { Success = false, Error = ex.Message });
|
|
};
|
|
}
|
|
});
|
|
}
|
|
|
|
private static SyncResult RunSync(string repoUrl, string installDir, string branch, string lastSyncedCommit, Action<string> log)
|
|
{
|
|
log?.Invoke("=== Sync Start ===");
|
|
|
|
if (!TryParseGitHubRepository(repoUrl, out var repoInfo))
|
|
{
|
|
throw new InvalidOperationException($"Repo URL is not a recognized GitHub repository URL: {repoUrl}");
|
|
}
|
|
|
|
log?.Invoke($"Target repository: {repoInfo.Owner}/{repoInfo.Repo}@{branch}");
|
|
var snapshot = FetchRemoteSnapshot(repoInfo, branch, SkillSubdir, log);
|
|
var installPath = ResolveAndValidateInstallPath(installDir);
|
|
|
|
if (!Directory.Exists(installPath))
|
|
{
|
|
Directory.CreateDirectory(installPath);
|
|
}
|
|
|
|
var localFiles = ListFiles(installPath);
|
|
var pathComparison = GetPathComparison(installPath);
|
|
var pathComparer = GetPathComparer(pathComparison);
|
|
EnsureManagedInstallRoot(installPath, localFiles.Keys, snapshot.Files.Keys, pathComparer);
|
|
var plan = BuildPlan(snapshot.Files, localFiles, pathComparer);
|
|
var commitChanged = !string.Equals(lastSyncedCommit, snapshot.CommitSha, StringComparison.Ordinal);
|
|
|
|
log?.Invoke($"Remote Commit: {ShortCommit(lastSyncedCommit)} -> {ShortCommit(snapshot.CommitSha)}");
|
|
log?.Invoke(commitChanged
|
|
? $"Commit: detected newer commit on {branch}."
|
|
: $"Commit: no new commit on {branch} since last sync.");
|
|
log?.Invoke($"Plan => Added:{plan.Added.Count} Updated:{plan.Updated.Count} Deleted:{plan.Deleted.Count}");
|
|
LogPlanDetails(plan, log);
|
|
|
|
ApplyPlan(repoInfo, snapshot.CommitSha, snapshot.SubdirPath, installPath, plan, pathComparison, log);
|
|
log?.Invoke("Files mirrored to install directory.");
|
|
|
|
ValidateFileHashes(installPath, snapshot.Files, pathComparison, log);
|
|
log?.Invoke($"Synced to commit: {snapshot.CommitSha}");
|
|
log?.Invoke("=== Sync Done ===");
|
|
|
|
return new SyncResult
|
|
{
|
|
Success = true,
|
|
Added = plan.Added.Count,
|
|
Updated = plan.Updated.Count,
|
|
Deleted = plan.Deleted.Count,
|
|
CommitSha = snapshot.CommitSha
|
|
};
|
|
}
|
|
|
|
private static string GetLastSyncedCommitKey(string repoUrl, string branch)
|
|
{
|
|
var scope = $"{repoUrl}|{branch}|{NormalizeRemotePath(SkillSubdir)}";
|
|
using var sha256 = SHA256.Create();
|
|
var hash = sha256.ComputeHash(Encoding.UTF8.GetBytes(scope));
|
|
var suffix = BitConverter.ToString(hash).Replace("-", string.Empty).ToLowerInvariant();
|
|
return $"{LastSyncedCommitKeyPrefix}.{suffix}";
|
|
}
|
|
|
|
internal static bool TryParseGitHubRepository(string url, out GitHubRepoInfo repoInfo)
|
|
{
|
|
repoInfo = default;
|
|
if (string.IsNullOrWhiteSpace(url))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var trimmed = url.Trim();
|
|
if (trimmed.StartsWith("git@github.com:", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
var repoPath = trimmed.Substring("git@github.com:".Length).Trim('/');
|
|
return TryParseOwnerAndRepo(repoPath, out repoInfo);
|
|
}
|
|
|
|
if (!Uri.TryCreate(trimmed, UriKind.Absolute, out var uri))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!string.Equals(uri.Host, "github.com", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var repoPathFromUri = uri.AbsolutePath.Trim('/');
|
|
return TryParseOwnerAndRepo(repoPathFromUri, out repoInfo);
|
|
}
|
|
|
|
private static bool TryParseOwnerAndRepo(string path, out GitHubRepoInfo repoInfo)
|
|
{
|
|
repoInfo = default;
|
|
var segments = path.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
|
|
if (segments.Length < 2)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var owner = segments[0].Trim();
|
|
var repo = segments[1].Trim();
|
|
if (repo.EndsWith(".git", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
repo = repo.Substring(0, repo.Length - 4);
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(owner) || string.IsNullOrWhiteSpace(repo))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
repoInfo = new GitHubRepoInfo(owner, repo);
|
|
return true;
|
|
}
|
|
|
|
private static RemoteSnapshot FetchRemoteSnapshot(GitHubRepoInfo repoInfo, string branch, string subdir, Action<string> log)
|
|
{
|
|
using var client = CreateGitHubClient();
|
|
var commitSha = FetchBranchHeadCommitSha(client, repoInfo, branch, log);
|
|
var treeApiUrl = BuildTreeApiUrl(repoInfo, commitSha);
|
|
log?.Invoke($"Fetching remote directory tree at commit {ShortCommit(commitSha)}...");
|
|
var json = DownloadString(client, treeApiUrl);
|
|
var treeResponse = JsonUtility.FromJson<GitHubTreeResponse>(json);
|
|
if (treeResponse == null || treeResponse.tree == null)
|
|
{
|
|
throw new InvalidOperationException("Failed to parse GitHub directory tree response.");
|
|
}
|
|
|
|
if (treeResponse.truncated)
|
|
{
|
|
throw new InvalidOperationException(
|
|
"GitHub returned a truncated directory tree (incomplete snapshot). " +
|
|
"Sync was aborted to prevent accidental deletion of valid local files.");
|
|
}
|
|
|
|
var normalizedSubdir = NormalizeRemotePath(subdir);
|
|
var subdirPrefix = string.IsNullOrEmpty(normalizedSubdir) ? string.Empty : $"{normalizedSubdir}/";
|
|
var remoteFiles = new Dictionary<string, string>(StringComparer.Ordinal);
|
|
|
|
foreach (var entry in treeResponse.tree)
|
|
{
|
|
if (!string.Equals(entry.type, "blob", StringComparison.Ordinal))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var remotePath = NormalizeRemotePath(entry.path);
|
|
if (string.IsNullOrEmpty(remotePath))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(subdirPrefix) &&
|
|
!remotePath.StartsWith(subdirPrefix, StringComparison.Ordinal))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var relativePath = string.IsNullOrEmpty(subdirPrefix)
|
|
? remotePath
|
|
: remotePath.Substring(subdirPrefix.Length);
|
|
if (string.IsNullOrWhiteSpace(relativePath) || string.IsNullOrWhiteSpace(entry.sha))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (!TryNormalizeRelativePath(relativePath, out var safeRelativePath))
|
|
{
|
|
log?.Invoke($"Skip unsafe remote path: {remotePath}");
|
|
continue;
|
|
}
|
|
|
|
remoteFiles[safeRelativePath] = entry.sha.Trim().ToLowerInvariant();
|
|
}
|
|
|
|
if (remoteFiles.Count == 0)
|
|
{
|
|
throw new InvalidOperationException($"Remote directory not found: {normalizedSubdir}");
|
|
}
|
|
|
|
log?.Invoke($"Remote file count: {remoteFiles.Count}");
|
|
return new RemoteSnapshot(commitSha, normalizedSubdir, remoteFiles);
|
|
}
|
|
|
|
private static string FetchBranchHeadCommitSha(HttpClient client, GitHubRepoInfo repoInfo, string branch, Action<string> log)
|
|
{
|
|
var branchApiUrl = BuildBranchApiUrl(repoInfo, branch);
|
|
log?.Invoke($"Fetching branch head commit...");
|
|
var branchJson = DownloadString(client, branchApiUrl);
|
|
var branchResponse = JsonUtility.FromJson<GitHubBranchResponse>(branchJson);
|
|
var commitSha = branchResponse?.commit?.sha?.Trim();
|
|
if (string.IsNullOrWhiteSpace(commitSha))
|
|
{
|
|
throw new InvalidOperationException($"Failed to resolve branch head commit SHA for: {branch}");
|
|
}
|
|
|
|
return commitSha;
|
|
}
|
|
|
|
private static string BuildBranchApiUrl(GitHubRepoInfo repoInfo, string branch)
|
|
{
|
|
return $"https://api.github.com/repos/{Uri.EscapeDataString(repoInfo.Owner)}/{Uri.EscapeDataString(repoInfo.Repo)}/branches/{Uri.EscapeDataString(branch)}";
|
|
}
|
|
|
|
private static string BuildTreeApiUrl(GitHubRepoInfo repoInfo, string reference)
|
|
{
|
|
return $"https://api.github.com/repos/{Uri.EscapeDataString(repoInfo.Owner)}/{Uri.EscapeDataString(repoInfo.Repo)}/git/trees/{Uri.EscapeDataString(reference)}?recursive=1";
|
|
}
|
|
|
|
private static string BuildRawFileUrl(GitHubRepoInfo repoInfo, string commitSha, string remoteFilePath)
|
|
{
|
|
var encodedPath = string.Join("/",
|
|
NormalizeRemotePath(remoteFilePath)
|
|
.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries)
|
|
.Select(Uri.EscapeDataString));
|
|
return $"https://raw.githubusercontent.com/{Uri.EscapeDataString(repoInfo.Owner)}/{Uri.EscapeDataString(repoInfo.Repo)}/{Uri.EscapeDataString(commitSha)}/{encodedPath}";
|
|
}
|
|
|
|
internal static HttpClient CreateGitHubClient()
|
|
{
|
|
var client = new HttpClient
|
|
{
|
|
Timeout = TimeSpan.FromSeconds(60)
|
|
};
|
|
client.DefaultRequestHeaders.UserAgent.ParseAdd("UnityMcpSkillSync/1.0");
|
|
client.DefaultRequestHeaders.Accept.ParseAdd("application/vnd.github+json");
|
|
return client;
|
|
}
|
|
|
|
internal static string DownloadString(HttpClient client, string url)
|
|
{
|
|
using var response = client.GetAsync(url).GetAwaiter().GetResult();
|
|
var body = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
|
|
if (!response.IsSuccessStatusCode)
|
|
{
|
|
throw new InvalidOperationException($"GitHub request failed: {(int)response.StatusCode} {response.ReasonPhrase} ({url})\n{body}");
|
|
}
|
|
|
|
return body;
|
|
}
|
|
|
|
private static byte[] DownloadBytes(HttpClient client, string url)
|
|
{
|
|
using var response = client.GetAsync(url).GetAwaiter().GetResult();
|
|
if (!response.IsSuccessStatusCode)
|
|
{
|
|
var body = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
|
|
throw new InvalidOperationException($"File download failed: {(int)response.StatusCode} {response.ReasonPhrase} ({url})\n{body}");
|
|
}
|
|
|
|
return response.Content.ReadAsByteArrayAsync().GetAwaiter().GetResult();
|
|
}
|
|
|
|
internal static string NormalizeRemotePath(string path)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(path))
|
|
{
|
|
return string.Empty;
|
|
}
|
|
|
|
return path.Replace('\\', '/').Trim().Trim('/');
|
|
}
|
|
|
|
private static string CombineRemotePath(string left, string right)
|
|
{
|
|
var normalizedLeft = NormalizeRemotePath(left);
|
|
var normalizedRight = NormalizeRemotePath(right);
|
|
if (string.IsNullOrEmpty(normalizedLeft))
|
|
{
|
|
return normalizedRight;
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(normalizedRight))
|
|
{
|
|
return normalizedLeft;
|
|
}
|
|
|
|
return $"{normalizedLeft}/{normalizedRight}";
|
|
}
|
|
|
|
internal static bool TryNormalizeRelativePath(string relativePath, out string normalizedPath)
|
|
{
|
|
normalizedPath = NormalizeRemotePath(relativePath);
|
|
if (string.IsNullOrWhiteSpace(normalizedPath) || Path.IsPathRooted(normalizedPath))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var segments = normalizedPath.Split('/');
|
|
if (segments.Length == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
foreach (var segment in segments)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(segment) ||
|
|
string.Equals(segment, ".", StringComparison.Ordinal) ||
|
|
string.Equals(segment, "..", StringComparison.Ordinal) ||
|
|
segment.IndexOf(':') >= 0)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
normalizedPath = string.Join("/", segments);
|
|
return true;
|
|
}
|
|
|
|
internal static string ResolvePathUnderRoot(string root, string relativePath, StringComparison pathComparison)
|
|
{
|
|
if (!TryNormalizeRelativePath(relativePath, out var safeRelativePath))
|
|
{
|
|
throw new InvalidOperationException($"Unsafe relative path: {relativePath}");
|
|
}
|
|
|
|
var normalizedRoot = EnsureTrailingDirectorySeparator(Path.GetFullPath(root));
|
|
var combinedPath = Path.Combine(normalizedRoot, safeRelativePath.Replace('/', Path.DirectorySeparatorChar));
|
|
var fullPath = Path.GetFullPath(combinedPath);
|
|
if (!fullPath.StartsWith(normalizedRoot, pathComparison))
|
|
{
|
|
throw new InvalidOperationException($"Path escapes install root: {relativePath}");
|
|
}
|
|
|
|
return fullPath;
|
|
}
|
|
|
|
private static string EnsureTrailingDirectorySeparator(string path)
|
|
{
|
|
return path.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar) + Path.DirectorySeparatorChar;
|
|
}
|
|
|
|
internal static SyncPlan BuildPlan(Dictionary<string, string> remoteFiles, Dictionary<string, string> localFiles, StringComparer pathComparer)
|
|
{
|
|
var plan = new SyncPlan();
|
|
var localLookup = new Dictionary<string, string>(pathComparer);
|
|
foreach (var localEntry in localFiles)
|
|
{
|
|
if (!localLookup.ContainsKey(localEntry.Key))
|
|
{
|
|
localLookup[localEntry.Key] = localEntry.Value;
|
|
}
|
|
}
|
|
|
|
foreach (var remoteEntry in remoteFiles)
|
|
{
|
|
if (!localLookup.TryGetValue(remoteEntry.Key, out var localPath))
|
|
{
|
|
plan.Added.Add(remoteEntry.Key);
|
|
continue;
|
|
}
|
|
|
|
var localBlobSha = ComputeGitBlobSha1(localPath);
|
|
if (!string.Equals(localBlobSha, remoteEntry.Value, StringComparison.Ordinal))
|
|
{
|
|
plan.Updated.Add(remoteEntry.Key);
|
|
}
|
|
}
|
|
|
|
var remoteLookup = new HashSet<string>(remoteFiles.Keys, pathComparer);
|
|
foreach (var localRelativePath in localFiles.Keys)
|
|
{
|
|
if (!remoteLookup.Contains(localRelativePath))
|
|
{
|
|
plan.Deleted.Add(localRelativePath);
|
|
}
|
|
}
|
|
|
|
plan.Added.Sort(StringComparer.Ordinal);
|
|
plan.Updated.Sort(StringComparer.Ordinal);
|
|
plan.Deleted.Sort(StringComparer.Ordinal);
|
|
return plan;
|
|
}
|
|
|
|
private static void ApplyPlan(GitHubRepoInfo repoInfo, string commitSha, string remoteSubdir, string targetRoot, SyncPlan plan, StringComparison pathComparison, Action<string> log)
|
|
{
|
|
using var client = CreateGitHubClient();
|
|
foreach (var relativePath in plan.Added.Concat(plan.Updated))
|
|
{
|
|
var remoteFilePath = CombineRemotePath(remoteSubdir, relativePath);
|
|
var downloadUrl = BuildRawFileUrl(repoInfo, commitSha, remoteFilePath);
|
|
var targetFile = ResolvePathUnderRoot(targetRoot, relativePath, pathComparison);
|
|
var targetDirectory = Path.GetDirectoryName(targetFile);
|
|
if (!string.IsNullOrEmpty(targetDirectory))
|
|
{
|
|
Directory.CreateDirectory(targetDirectory);
|
|
}
|
|
|
|
log?.Invoke($"Download: {relativePath}");
|
|
var bytes = DownloadBytes(client, downloadUrl);
|
|
File.WriteAllBytes(targetFile, bytes);
|
|
}
|
|
|
|
foreach (var relativePath in plan.Deleted)
|
|
{
|
|
var targetFile = ResolvePathUnderRoot(targetRoot, relativePath, pathComparison);
|
|
if (File.Exists(targetFile))
|
|
{
|
|
File.Delete(targetFile);
|
|
}
|
|
}
|
|
|
|
RemoveEmptyDirectories(targetRoot);
|
|
}
|
|
|
|
private static void ValidateFileHashes(string installRoot, Dictionary<string, string> remoteFiles, StringComparison pathComparison, Action<string> log)
|
|
{
|
|
var checkedCount = 0;
|
|
foreach (var remoteEntry in remoteFiles)
|
|
{
|
|
var localPath = ResolvePathUnderRoot(installRoot, remoteEntry.Key, pathComparison);
|
|
if (!File.Exists(localPath))
|
|
{
|
|
throw new InvalidOperationException($"Missing synced file: {remoteEntry.Key}");
|
|
}
|
|
|
|
var localBlobSha = ComputeGitBlobSha1(localPath);
|
|
if (!string.Equals(localBlobSha, remoteEntry.Value, StringComparison.Ordinal))
|
|
{
|
|
throw new InvalidOperationException($"File hash mismatch: {remoteEntry.Key} ({ShortHash(localBlobSha)} != {ShortHash(remoteEntry.Value)})");
|
|
}
|
|
|
|
checkedCount++;
|
|
}
|
|
|
|
log?.Invoke($"Hash checks passed ({checkedCount}/{remoteFiles.Count}).");
|
|
}
|
|
|
|
internal static string ComputeGitBlobSha1(string filePath)
|
|
{
|
|
var bytes = File.ReadAllBytes(filePath);
|
|
return ComputeGitBlobSha1(bytes);
|
|
}
|
|
|
|
internal static string ComputeGitBlobSha1(byte[] bytes)
|
|
{
|
|
var headerBytes = Encoding.UTF8.GetBytes($"blob {bytes.Length}\0");
|
|
using var sha1 = SHA1.Create();
|
|
sha1.TransformBlock(headerBytes, 0, headerBytes.Length, null, 0);
|
|
sha1.TransformFinalBlock(bytes, 0, bytes.Length);
|
|
return BitConverter.ToString(sha1.Hash ?? Array.Empty<byte>()).Replace("-", string.Empty).ToLowerInvariant();
|
|
}
|
|
|
|
internal static Dictionary<string, string> ListFiles(string root)
|
|
{
|
|
var map = new Dictionary<string, string>(StringComparer.Ordinal);
|
|
if (!Directory.Exists(root))
|
|
{
|
|
return map;
|
|
}
|
|
|
|
var normalizedRoot = Path.GetFullPath(root);
|
|
foreach (var filePath in Directory.GetFiles(normalizedRoot, "*", SearchOption.AllDirectories))
|
|
{
|
|
var relativePath = Path.GetRelativePath(normalizedRoot, filePath).Replace('\\', '/');
|
|
if (string.Equals(relativePath, SyncOwnershipMarker, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
map[relativePath] = filePath;
|
|
}
|
|
|
|
return map;
|
|
}
|
|
|
|
private static void EnsureManagedInstallRoot(
|
|
string installPath,
|
|
ICollection<string> localRelativePaths,
|
|
ICollection<string> remoteRelativePaths,
|
|
StringComparer pathComparer)
|
|
{
|
|
var markerPath = Path.Combine(installPath, SyncOwnershipMarker);
|
|
if (File.Exists(markerPath))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (localRelativePaths.Count > 0 && !CanAdoptLegacyManagedRoot(localRelativePaths, remoteRelativePaths, pathComparer))
|
|
{
|
|
throw new InvalidOperationException(
|
|
"Install Dir contains unmanaged files. " +
|
|
"Please choose an empty folder or an existing unity-mcp-skill folder.");
|
|
}
|
|
|
|
File.WriteAllText(markerPath, "managed-by-unity-mcp-skill-sync");
|
|
}
|
|
|
|
private static bool CanAdoptLegacyManagedRoot(
|
|
ICollection<string> localRelativePaths,
|
|
ICollection<string> remoteRelativePaths,
|
|
StringComparer pathComparer)
|
|
{
|
|
if (localRelativePaths.Count == 0)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
var remoteTopLevels = new HashSet<string>(pathComparer);
|
|
foreach (var remotePath in remoteRelativePaths)
|
|
{
|
|
var topLevel = GetTopLevelSegment(remotePath);
|
|
if (!string.IsNullOrWhiteSpace(topLevel))
|
|
{
|
|
remoteTopLevels.Add(topLevel);
|
|
}
|
|
}
|
|
|
|
if (remoteTopLevels.Count == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var hasSkillDefinition = false;
|
|
foreach (var localPath in localRelativePaths)
|
|
{
|
|
if (pathComparer.Equals(localPath, "SKILL.md"))
|
|
{
|
|
hasSkillDefinition = true;
|
|
}
|
|
|
|
var topLevel = GetTopLevelSegment(localPath);
|
|
if (string.IsNullOrWhiteSpace(topLevel) || !remoteTopLevels.Contains(topLevel))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return hasSkillDefinition;
|
|
}
|
|
|
|
private static string GetTopLevelSegment(string relativePath)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(relativePath))
|
|
{
|
|
return string.Empty;
|
|
}
|
|
|
|
var normalized = NormalizeRemotePath(relativePath);
|
|
var separatorIndex = normalized.IndexOf('/');
|
|
return separatorIndex < 0 ? normalized : normalized.Substring(0, separatorIndex);
|
|
}
|
|
|
|
internal static StringComparison GetPathComparison(string root)
|
|
{
|
|
return IsCaseSensitiveFileSystem(root) ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;
|
|
}
|
|
|
|
internal static StringComparer GetPathComparer(StringComparison pathComparison)
|
|
{
|
|
return pathComparison == StringComparison.Ordinal
|
|
? StringComparer.Ordinal
|
|
: StringComparer.OrdinalIgnoreCase;
|
|
}
|
|
|
|
private static bool IsCaseSensitiveFileSystem(string root)
|
|
{
|
|
try
|
|
{
|
|
var probeName = $".mcp-case-probe-{Guid.NewGuid():N}";
|
|
var lowercasePath = Path.Combine(root, probeName.ToLowerInvariant());
|
|
var uppercasePath = Path.Combine(root, probeName.ToUpperInvariant());
|
|
File.WriteAllText(lowercasePath, string.Empty);
|
|
try
|
|
{
|
|
return !File.Exists(uppercasePath);
|
|
}
|
|
finally
|
|
{
|
|
if (File.Exists(lowercasePath))
|
|
{
|
|
File.Delete(lowercasePath);
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
private static void RemoveEmptyDirectories(string root)
|
|
{
|
|
if (!Directory.Exists(root))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var directories = Directory.GetDirectories(root, "*", SearchOption.AllDirectories);
|
|
Array.Sort(directories, (a, b) => string.CompareOrdinal(b, a));
|
|
foreach (var directory in directories)
|
|
{
|
|
if (Directory.EnumerateFileSystemEntries(directory).Any())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
Directory.Delete(directory, false);
|
|
}
|
|
}
|
|
|
|
internal static string ResolveAndValidateInstallPath(string installDir)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(installDir))
|
|
{
|
|
throw new InvalidOperationException("Install Dir is empty.");
|
|
}
|
|
|
|
var trimmed = installDir.Trim();
|
|
if (trimmed.IndexOfAny(Path.GetInvalidPathChars()) >= 0)
|
|
{
|
|
throw new InvalidOperationException($"Install Dir contains invalid path characters: {installDir}");
|
|
}
|
|
|
|
string expandedPath;
|
|
try
|
|
{
|
|
expandedPath = ExpandPath(trimmed);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new InvalidOperationException($"Install Dir is invalid and cannot be resolved: {installDir}", ex);
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(expandedPath))
|
|
{
|
|
throw new InvalidOperationException("Install Dir resolved to an empty path.");
|
|
}
|
|
|
|
return expandedPath;
|
|
}
|
|
|
|
internal static string ExpandPath(string path)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(path))
|
|
{
|
|
return string.Empty;
|
|
}
|
|
|
|
var expanded = path.Trim();
|
|
if (expanded.StartsWith("~", StringComparison.Ordinal))
|
|
{
|
|
var userHome = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
|
|
expanded = Path.Combine(userHome, expanded.Substring(1).TrimStart('/', '\\'));
|
|
}
|
|
|
|
return Path.GetFullPath(expanded);
|
|
}
|
|
|
|
private static string ShortCommit(string commit)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(commit))
|
|
{
|
|
return "(none)";
|
|
}
|
|
|
|
return commit.Length <= 8 ? commit : commit.Substring(0, 8);
|
|
}
|
|
|
|
private static string ShortHash(string hash)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(hash))
|
|
{
|
|
return "(none)";
|
|
}
|
|
|
|
return hash.Length <= 6 ? hash : hash.Substring(0, 6);
|
|
}
|
|
|
|
private static void LogPlanDetails(SyncPlan plan, Action<string> log)
|
|
{
|
|
if (plan.Added.Count == 0 && plan.Updated.Count == 0 && plan.Deleted.Count == 0)
|
|
{
|
|
log?.Invoke("No file changes.");
|
|
return;
|
|
}
|
|
|
|
foreach (var path in plan.Added)
|
|
{
|
|
log?.Invoke($"+ {path}");
|
|
}
|
|
|
|
foreach (var path in plan.Updated)
|
|
{
|
|
log?.Invoke($"~ {path}");
|
|
}
|
|
|
|
foreach (var path in plan.Deleted)
|
|
{
|
|
log?.Invoke($"- {path}");
|
|
}
|
|
}
|
|
|
|
internal readonly struct GitHubRepoInfo
|
|
{
|
|
public GitHubRepoInfo(string owner, string repo)
|
|
{
|
|
Owner = owner;
|
|
Repo = repo;
|
|
}
|
|
|
|
public string Owner { get; }
|
|
public string Repo { get; }
|
|
}
|
|
|
|
internal readonly struct RemoteSnapshot
|
|
{
|
|
public RemoteSnapshot(string commitSha, string subdirPath, Dictionary<string, string> files)
|
|
{
|
|
CommitSha = commitSha;
|
|
SubdirPath = subdirPath;
|
|
Files = files;
|
|
}
|
|
|
|
public string CommitSha { get; }
|
|
public string SubdirPath { get; }
|
|
public Dictionary<string, string> Files { get; }
|
|
}
|
|
|
|
[Serializable]
|
|
internal sealed class GitHubTreeResponse
|
|
{
|
|
public string sha;
|
|
public GitHubTreeEntry[] tree;
|
|
public bool truncated;
|
|
}
|
|
|
|
[Serializable]
|
|
internal sealed class GitHubBranchResponse
|
|
{
|
|
public GitHubBranchCommit commit;
|
|
}
|
|
|
|
[Serializable]
|
|
internal sealed class GitHubBranchCommit
|
|
{
|
|
public string sha;
|
|
}
|
|
|
|
[Serializable]
|
|
internal sealed class GitHubTreeEntry
|
|
{
|
|
public string path;
|
|
public string type;
|
|
public string sha;
|
|
}
|
|
|
|
internal sealed class SyncPlan
|
|
{
|
|
public List<string> Added { get; } = new();
|
|
public List<string> Updated { get; } = new();
|
|
public List<string> Deleted { get; } = new();
|
|
}
|
|
}
|
|
}
|