mirror of
https://github.com/soarqin/DSP_Mods.git
synced 2026-11-19 17:05:20 +08:00
feat(publish): add local Thunderstore publishing script
This commit is contained in:
1 parent
e876db396a
commit
9f48923166
6 files changed
+951
No files matched your search
+386
@@ -0,0 +1,386 @@
|
||||
#requires -Version 5.1
|
||||
<#
|
||||
.SYNOPSIS
|
||||
Builds and publishes one mod to the Dyson Sphere Program Thunderstore community.
|
||||
.PARAMETER EnvFile
|
||||
Optional token file. Defaults to .env in the caller's current directory when present,
|
||||
otherwise TCLI_AUTH_TOKEN is read from the process environment.
|
||||
.EXAMPLE
|
||||
.\Publish-Mod.ps1 -Project UXAssist -Namespace soarqin -DryRun
|
||||
.EXAMPLE
|
||||
.\Publish-Mod.ps1 -Project Dustbin -Namespace soarqin -EnvFile C:\Secrets\thunderstore.env
|
||||
#>
|
||||
[CmdletBinding()]
|
||||
param(
|
||||
[Parameter(Mandatory = $true)]
|
||||
[ValidatePattern('^[A-Za-z0-9_][A-Za-z0-9_.-]*\z')]
|
||||
[string]$Project,
|
||||
|
||||
[Parameter(Mandatory = $true)]
|
||||
[ValidatePattern('^[A-Za-z0-9_]+\z')]
|
||||
[string]$Namespace,
|
||||
|
||||
[string]$EnvFile,
|
||||
[switch]$DryRun
|
||||
)
|
||||
|
||||
Set-StrictMode -Version Latest
|
||||
$ErrorActionPreference = 'Stop'
|
||||
|
||||
function Invoke-PublishDotNet {
|
||||
param([string[]]$Arguments, [switch]$Capture, [string]$Secret)
|
||||
|
||||
$previousOutputEncoding = [Console]::OutputEncoding
|
||||
try {
|
||||
# Localized .NET SDK output is UTF-8. PowerShell decodes native output
|
||||
# with Console.OutputEncoding, which can still be a legacy code page.
|
||||
[Console]::OutputEncoding = [Text.UTF8Encoding]::new($false)
|
||||
|
||||
# Windows PowerShell turns native stderr into error records. Check the exit
|
||||
# code ourselves and redact credentials before forwarding any tcli output.
|
||||
$ErrorActionPreference = 'Continue'
|
||||
$lines = New-Object 'System.Collections.Generic.List[string]'
|
||||
& dotnet @Arguments 2>&1 | ForEach-Object {
|
||||
$line = $_.ToString()
|
||||
if (-not [string]::IsNullOrEmpty($Secret)) { $line = $line.Replace($Secret, '[REDACTED]') }
|
||||
if ($Capture) { $lines.Add($line) } else { Write-Host $line }
|
||||
}
|
||||
$commandExit = $LASTEXITCODE
|
||||
if ($commandExit -ne 0) {
|
||||
if ($Capture) { foreach ($line in $lines) { Write-Host $line } }
|
||||
throw "dotnet $($Arguments[0]) failed (exit $commandExit). No further publishing steps were run."
|
||||
}
|
||||
if ($Capture) { return ($lines -join [Environment]::NewLine) }
|
||||
} finally { [Console]::OutputEncoding = $previousOutputEncoding }
|
||||
}
|
||||
|
||||
function Get-PublishJsonProperty {
|
||||
param($Object, [string]$Name)
|
||||
if ($null -ne $Object) {
|
||||
$property = $Object.PSObject.Properties[$Name]
|
||||
if ($null -ne $property) { return $property.Value }
|
||||
}
|
||||
return $null
|
||||
}
|
||||
|
||||
function Read-PublishJson {
|
||||
param([string]$Path)
|
||||
try { return ([IO.File]::ReadAllText($Path) | ConvertFrom-Json -ErrorAction Stop) }
|
||||
catch { throw "Cannot read JSON from '$Path'. Check that it is a valid JSON object." }
|
||||
}
|
||||
|
||||
function Get-PublishProject {
|
||||
param([string]$Path)
|
||||
$query = Invoke-PublishDotNet -Capture -Arguments @(
|
||||
'msbuild', $Path, '-nologo', '-verbosity:quiet', '-property:Configuration=Release',
|
||||
'-getProperty:Version,ProjectName,TargetPath,PackHasChangelog,PackUsePluginsLayout,PackPreloaderTargetDir,ProjectAssetsFile',
|
||||
'-getItem:ProjectReference'
|
||||
)
|
||||
try { $result = $query | ConvertFrom-Json -ErrorAction Stop }
|
||||
catch { throw "Cannot evaluate '$Path'. MSBuild 17.8 or newer is required; check 'dotnet msbuild -version'." }
|
||||
if ($null -eq (Get-PublishJsonProperty $result 'Properties')) { throw "MSBuild returned no properties for '$Path'." }
|
||||
return $result
|
||||
}
|
||||
|
||||
function Test-PublishPathWithin {
|
||||
param([string]$Path, [string]$Directory)
|
||||
$fullPath = [IO.Path]::GetFullPath($Path).TrimEnd('\', '/')
|
||||
$fullDirectory = [IO.Path]::GetFullPath($Directory).TrimEnd('\', '/')
|
||||
return ($fullPath.Equals($fullDirectory, [StringComparison]::OrdinalIgnoreCase) -or
|
||||
$fullPath.StartsWith($fullDirectory + [IO.Path]::DirectorySeparatorChar, [StringComparison]::OrdinalIgnoreCase))
|
||||
}
|
||||
|
||||
function Get-PublishPhysicalPath {
|
||||
param([string]$Path)
|
||||
# Resolve parent junctions as well as file symlinks on .NET Framework 4.x.
|
||||
if (-not ('DSPModPublish.PhysicalPath' -as [type])) {
|
||||
Add-Type -TypeDefinition @'
|
||||
using System;
|
||||
using System.ComponentModel;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
using Microsoft.Win32.SafeHandles;
|
||||
namespace DSPModPublish {
|
||||
public static class PhysicalPath {
|
||||
[DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
|
||||
private static extern SafeFileHandle CreateFile(string name, uint access, uint share,
|
||||
IntPtr security, uint disposition, uint flags, IntPtr template);
|
||||
[DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
|
||||
private static extern uint GetFinalPathNameByHandle(SafeFileHandle file,
|
||||
StringBuilder path, uint length, uint flags);
|
||||
public static string Resolve(string path) {
|
||||
using (var handle = CreateFile(path, 0, 7, IntPtr.Zero, 3, 0x02000000, IntPtr.Zero)) {
|
||||
if (handle.IsInvalid) throw new Win32Exception(Marshal.GetLastWin32Error());
|
||||
var buffer = new StringBuilder(32768);
|
||||
var length = GetFinalPathNameByHandle(handle, buffer, (uint)buffer.Capacity, 0);
|
||||
if (length == 0 || length >= buffer.Capacity)
|
||||
throw new Win32Exception(Marshal.GetLastWin32Error());
|
||||
var result = buffer.ToString();
|
||||
if (result.StartsWith(@"\\?\UNC\")) return @"\\" + result.Substring(8);
|
||||
return result.StartsWith(@"\\?\") ? result.Substring(4) : result;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
'@
|
||||
}
|
||||
return [DSPModPublish.PhysicalPath]::Resolve([IO.Path]::GetFullPath($Path))
|
||||
}
|
||||
|
||||
function Get-PublishToken {
|
||||
param([string]$EnvironmentFile)
|
||||
if ([string]::IsNullOrWhiteSpace($EnvironmentFile)) {
|
||||
$defaultFile = $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath('.env')
|
||||
if ([IO.File]::Exists($defaultFile)) { $EnvironmentFile = $defaultFile }
|
||||
}
|
||||
if (-not [string]::IsNullOrWhiteSpace($EnvironmentFile)) {
|
||||
$filePath = $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath($EnvironmentFile)
|
||||
if (-not [IO.File]::Exists($filePath)) { throw 'The environment file does not exist. Supply a UTF-8 file with TCLI_AUTH_TOKEN.' }
|
||||
$token = $null
|
||||
foreach ($line in [IO.File]::ReadAllLines($filePath, [Text.UTF8Encoding]::new($false, $true))) {
|
||||
if ($line -match '^\s*(#.*)?$') { continue }
|
||||
if ($line -notmatch '^\s*TCLI_AUTH_TOKEN\s*=\s*(.*?)\s*$' -or $null -ne $token) {
|
||||
throw 'Invalid environment file. Use one TCLI_AUTH_TOKEN assignment, optional blank lines, and full-line comments.'
|
||||
}
|
||||
$token = $Matches[1]
|
||||
if ($token.StartsWith('"') -or $token.StartsWith("'")) {
|
||||
if ($token.Length -lt 2 -or $token[0] -ne $token[$token.Length - 1]) { throw 'The token has unmatched quotes in the environment file.' }
|
||||
$token = $token.Substring(1, $token.Length - 2)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
$token = [Environment]::GetEnvironmentVariable('TCLI_AUTH_TOKEN', 'Process')
|
||||
}
|
||||
if ([string]::IsNullOrWhiteSpace($token) -or $token -match '\s') {
|
||||
throw 'Set a non-empty TCLI_AUTH_TOKEN without whitespace, create .env in the current directory, or supply -EnvFile.'
|
||||
}
|
||||
# tcli 0.2.4 reads the persisted Windows User value before the process value.
|
||||
$userToken = Get-PublishUserToken
|
||||
if (-not [string]::IsNullOrWhiteSpace($userToken) -and $userToken -cne $token) {
|
||||
throw 'A different User-scoped TCLI_AUTH_TOKEN overrides the selected token in tcli. Remove or reconcile that setting before retrying.'
|
||||
}
|
||||
return $token
|
||||
}
|
||||
|
||||
function Get-PublishUserToken {
|
||||
return [Environment]::GetEnvironmentVariable('TCLI_AUTH_TOKEN', 'User')
|
||||
}
|
||||
|
||||
function Assert-PublishChangelog {
|
||||
param([string]$Text, [string]$Version)
|
||||
$sections = @([regex]::Matches($Text, '(?is)<details\b[^>]*>(.*?)</details>') | ForEach-Object { $_.Groups[1].Value })
|
||||
if ($sections.Count -eq 0) { $sections = @($Text) }
|
||||
foreach ($section in $sections) {
|
||||
$latest = [regex]::Match($section, '(?m)^\s*(?:[*-]\s+|#{1,6}\s+)(\d+\.\d+\.\d+)(?=\s|$)')
|
||||
if (-not $latest.Success -or $latest.Groups[1].Value -cne $Version) {
|
||||
throw "The latest changelog entry in every language must match project version $Version. Update the release notes before publishing."
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function Get-PublishStreamHash {
|
||||
param([IO.Stream]$Stream)
|
||||
$hash = [Security.Cryptography.SHA256]::Create()
|
||||
try { return [BitConverter]::ToString($hash.ComputeHash($Stream)) }
|
||||
finally { $hash.Dispose() }
|
||||
}
|
||||
|
||||
function Assert-PublishArchive {
|
||||
param([string]$ZipPath, [string]$PackageName, [string]$Version, [hashtable]$Files, [bool]$HasChangelog)
|
||||
Add-Type -AssemblyName System.IO.Compression.FileSystem
|
||||
Add-Type -AssemblyName System.Drawing
|
||||
$archive = [IO.Compression.ZipFile]::OpenRead($ZipPath)
|
||||
try {
|
||||
$entries = @{}
|
||||
foreach ($entry in $archive.Entries) {
|
||||
$entryName = $entry.FullName.Replace('\', '/')
|
||||
if ($entryName -match '(^/|:|(^|/)\.\.(/|$))' -or $entries.ContainsKey($entryName)) {
|
||||
throw 'The ZIP contains an unsafe path or duplicate entry. Rebuild the package.'
|
||||
}
|
||||
if ($entryName -match '(^|/)(\.env(?:\..*)?|thunderstore\.toml)$') { throw 'The ZIP contains a local publishing or credential file.' }
|
||||
$entries[$entryName] = $entry
|
||||
}
|
||||
foreach ($entryName in $Files.Keys) {
|
||||
if (-not $entries.ContainsKey($entryName) -or $entries[$entryName].FullName -cne $entryName) {
|
||||
throw "The ZIP is missing the expected file '$entryName'. Rebuild the package."
|
||||
}
|
||||
$zipStream = $entries[$entryName].Open()
|
||||
$fileStream = [IO.File]::OpenRead($Files[$entryName])
|
||||
try {
|
||||
if ((Get-PublishStreamHash $zipStream) -cne (Get-PublishStreamHash $fileStream)) {
|
||||
throw "The ZIP file '$entryName' differs from its current source or build output. Rebuild the package."
|
||||
}
|
||||
} finally { $zipStream.Dispose(); $fileStream.Dispose() }
|
||||
}
|
||||
$reader = [IO.StreamReader]::new($entries['manifest.json'].Open(), [Text.Encoding]::UTF8, $true)
|
||||
try { $manifest = $reader.ReadToEnd() | ConvertFrom-Json -ErrorAction Stop } finally { $reader.Dispose() }
|
||||
if ((Get-PublishJsonProperty $manifest 'name') -cne $PackageName -or
|
||||
(Get-PublishJsonProperty $manifest 'version_number') -cne $Version) {
|
||||
throw 'The ZIP manifest does not match the selected package name and project version.'
|
||||
}
|
||||
$iconStream = $entries['icon.png'].Open()
|
||||
try {
|
||||
$icon = [Drawing.Image]::FromStream($iconStream)
|
||||
try {
|
||||
if ($icon.RawFormat.Guid -ne [Drawing.Imaging.ImageFormat]::Png.Guid -or $icon.Width -ne 256 -or $icon.Height -ne 256) {
|
||||
throw 'The package icon must be a 256x256 PNG.'
|
||||
}
|
||||
} finally { $icon.Dispose() }
|
||||
} finally { $iconStream.Dispose() }
|
||||
if ($HasChangelog) {
|
||||
$reader = [IO.StreamReader]::new($entries['CHANGELOG.md'].Open(), [Text.Encoding]::UTF8, $true)
|
||||
try { Assert-PublishChangelog $reader.ReadToEnd() $Version } finally { $reader.Dispose() }
|
||||
}
|
||||
} finally { $archive.Dispose() }
|
||||
}
|
||||
|
||||
function Assert-PublishVersionAvailable {
|
||||
param([string]$Namespace, [string]$PackageName, [string]$Version)
|
||||
$endpoint = "https://thunderstore.io/api/experimental/package/$Namespace/$PackageName/$Version/"
|
||||
try {
|
||||
$response = Invoke-RestMethod -Uri $endpoint -Method Get -TimeoutSec 30 -ErrorAction Stop
|
||||
} catch {
|
||||
$httpResponse = Get-PublishJsonProperty $_.Exception 'Response'
|
||||
$status = Get-PublishJsonProperty $httpResponse 'StatusCode'
|
||||
if ($null -ne $status -and [int]$status -eq 404) { return }
|
||||
throw "Cannot check the remote version at $endpoint. Check connectivity and the server response before retrying; nothing was uploaded."
|
||||
}
|
||||
if ((Get-PublishJsonProperty $response 'namespace') -cne $Namespace -or
|
||||
(Get-PublishJsonProperty $response 'name') -cne $PackageName -or
|
||||
(Get-PublishJsonProperty $response 'version_number') -cne $Version) {
|
||||
throw 'The package-version endpoint returned an unexpected response. Nothing was uploaded.'
|
||||
}
|
||||
throw "Version $Namespace-$PackageName-$Version already exists. Select an unpublished project version; this script does not bump versions."
|
||||
}
|
||||
|
||||
function Invoke-ModPublish {
|
||||
param([string]$RepositoryRoot, [string]$Project, [string]$Namespace, [string]$EnvFile, [switch]$DryRun)
|
||||
if ($Project -notmatch '^[A-Za-z0-9_][A-Za-z0-9_.-]*\z' -or $Namespace -notmatch '^[A-Za-z0-9_]+\z') {
|
||||
throw 'Supply one top-level -Project directory name and a non-empty alphanumeric/underscore -Namespace.'
|
||||
}
|
||||
$projectDir = Join-Path $RepositoryRoot $Project
|
||||
$projectPath = Join-Path $projectDir "$Project.csproj"
|
||||
$packageDir = Join-Path $projectDir 'package'
|
||||
foreach ($required in @($projectPath, (Join-Path $packageDir 'manifest.json'), (Join-Path $packageDir 'icon.png'), (Join-Path $projectDir 'README.md'))) {
|
||||
if (-not [IO.File]::Exists($required)) {
|
||||
if ($Project.EndsWith('Preloader', [StringComparison]::OrdinalIgnoreCase)) {
|
||||
throw "Select the main mod with -Project $($Project.Substring(0, $Project.Length - 9)); preloaders are bundled, not published separately."
|
||||
}
|
||||
throw "Required project/package file not found: $required. Select a packaged main mod, not a helper project."
|
||||
}
|
||||
}
|
||||
$manifestPath = Join-Path $packageDir 'manifest.json'
|
||||
$packageName = Get-PublishJsonProperty (Read-PublishJson $manifestPath) 'name'
|
||||
if ($packageName -isnot [string] -or $packageName -notmatch '^[A-Za-z0-9_]+\z') { throw 'The manifest must have a valid, non-empty string name.' }
|
||||
$token = $null
|
||||
# Resolve token files before changing to the repository's build directory.
|
||||
if (-not $DryRun) { $token = Get-PublishToken $EnvFile }
|
||||
$oldToken = [Environment]::GetEnvironmentVariable('TCLI_AUTH_TOKEN', 'Process')
|
||||
$configDir = $null
|
||||
$configPath = $null
|
||||
$configBase = Join-Path $projectDir 'obj\thunderstore-publish'
|
||||
Push-Location -LiteralPath $RepositoryRoot
|
||||
try {
|
||||
$null = Get-Command dotnet -CommandType Application -ErrorAction Stop
|
||||
if (-not $DryRun) {
|
||||
try { Invoke-PublishDotNet -Arguments @('tool', 'run', 'tcli', '--', '--version') }
|
||||
catch { throw 'The pinned tcli tool cannot run. Run dotnet tool restore in the repository root and check its required .NET runtime.' }
|
||||
}
|
||||
$metadata = Get-PublishProject $projectPath
|
||||
$properties = $metadata.Properties
|
||||
if (-not [string]::IsNullOrEmpty($properties.PackPreloaderTargetDir)) { throw 'Select a main mod; this project is a preloader or helper.' }
|
||||
$version = $properties.Version
|
||||
if ($version -notmatch '^[0-9]+\.[0-9]+\.[0-9]+\z') { throw 'The evaluated project Version must have the Thunderstore format major.minor.patch.' }
|
||||
$bundled = @()
|
||||
$needsRestore = -not [IO.File]::Exists($properties.ProjectAssetsFile)
|
||||
foreach ($reference in @($metadata.Items.ProjectReference)) {
|
||||
$referenceMetadata = Get-PublishProject $reference.FullPath
|
||||
$referenceProperties = $referenceMetadata.Properties
|
||||
if (-not [IO.File]::Exists($referenceProperties.ProjectAssetsFile)) { $needsRestore = $true }
|
||||
if ([string]::IsNullOrEmpty($referenceProperties.PackPreloaderTargetDir)) { continue }
|
||||
$targetDir = $referenceProperties.PackPreloaderTargetDir
|
||||
if (-not [IO.Path]::IsPathRooted($targetDir)) { $targetDir = Join-Path ([IO.Path]::GetDirectoryName($reference.FullPath)) $targetDir }
|
||||
$targetDir = [IO.Path]::GetFullPath($targetDir)
|
||||
if (Test-PublishPathWithin $targetDir $packageDir) {
|
||||
$bundled += [pscustomobject]@{ Path = $reference.FullPath; TargetDir = $targetDir; Output = $referenceProperties.TargetPath }
|
||||
}
|
||||
}
|
||||
if ($needsRestore) { Invoke-PublishDotNet -Arguments @('restore', $projectPath) }
|
||||
foreach ($preloader in $bundled) {
|
||||
Invoke-PublishDotNet -Arguments @('build', $preloader.Path, '-t:CopyToParentPackage', '-c', 'Release', '--no-restore')
|
||||
}
|
||||
Invoke-PublishDotNet -Arguments @('build', $projectPath, '-t:ZipMod', '-c', 'Release', '--no-restore')
|
||||
$zipPath = Join-Path $packageDir "$($properties.ProjectName)-$version.zip"
|
||||
if (-not [IO.File]::Exists($zipPath)) { throw "The build did not produce the expected ZIP: $zipPath" }
|
||||
$files = @{
|
||||
'manifest.json' = $manifestPath
|
||||
'icon.png' = Join-Path $packageDir 'icon.png'
|
||||
'README.md' = Join-Path $projectDir 'README.md'
|
||||
}
|
||||
$dllName = [IO.Path]::GetFileName($properties.TargetPath)
|
||||
$hasChangelog = $properties.PackHasChangelog -eq 'true'
|
||||
if ($properties.PackUsePluginsLayout -eq 'true') { $files["plugins/$dllName"] = $properties.TargetPath }
|
||||
else { $files[$dllName] = $properties.TargetPath }
|
||||
foreach ($preloader in $bundled) {
|
||||
$relativeDir = $preloader.TargetDir.Substring($packageDir.Length).TrimStart('\', '/').Replace('\', '/')
|
||||
$entryName = ($relativeDir + '/' + [IO.Path]::GetFileName($preloader.Output)).TrimStart('/')
|
||||
$files[$entryName] = $preloader.Output
|
||||
}
|
||||
if ($hasChangelog) { $files['CHANGELOG.md'] = Join-Path $projectDir 'CHANGELOG.md' }
|
||||
Assert-PublishArchive $zipPath $packageName $version $files $hasChangelog
|
||||
|
||||
$configDir = Join-Path $configBase ([Guid]::NewGuid().ToString('N'))
|
||||
$null = [IO.Directory]::CreateDirectory($configDir)
|
||||
$configPath = Join-Path $configDir 'thunderstore.toml'
|
||||
$configText = @"
|
||||
[config]
|
||||
schemaVersion = "0.0.1"
|
||||
|
||||
[package]
|
||||
namespace = "$Namespace"
|
||||
name = "$packageName"
|
||||
versionNumber = "$version"
|
||||
|
||||
[build]
|
||||
outdir = "."
|
||||
|
||||
[publish]
|
||||
repository = "https://thunderstore.io"
|
||||
communities = ["dyson-sphere-program"]
|
||||
categories = []
|
||||
"@
|
||||
[IO.File]::WriteAllText($configPath, $configText + [Environment]::NewLine, [Text.UTF8Encoding]::new($false))
|
||||
Write-Host "Project: $Project | Team: $Namespace | Package: $packageName | Version: $version"
|
||||
Write-Host 'Community: dyson-sphere-program | Categories: empty (retain existing listing categories)'
|
||||
Write-Host "ZIP: $zipPath"
|
||||
Write-Host ('dotnet tool run tcli -- publish --config-path "{0}" --file "{1}"' -f $configPath, $zipPath)
|
||||
if ($DryRun) { Write-Host 'Dry run complete. Package validated; no upload was attempted.'; return }
|
||||
|
||||
Assert-PublishVersionAvailable $Namespace $packageName $version
|
||||
[Environment]::SetEnvironmentVariable('TCLI_AUTH_TOKEN', $token, 'Process')
|
||||
try { Invoke-PublishDotNet -Arguments @('tool', 'run', 'tcli', '--', 'publish', '--config-path', $configPath, '--file', $zipPath) -Secret $token }
|
||||
catch { throw "Publication did not finish successfully. Inspect https://thunderstore.io/c/dyson-sphere-program/p/$Namespace/$packageName/v/$version/ before retrying; a submission may already have succeeded." }
|
||||
Write-Host "Published: https://thunderstore.io/c/dyson-sphere-program/p/$Namespace/$packageName/"
|
||||
} finally {
|
||||
# PowerShell converts $null to an empty string for this .NET call.
|
||||
# Modern runtimes preserve empty environment values; use a true null.
|
||||
if ($null -eq $oldToken) { [Environment]::SetEnvironmentVariable('TCLI_AUTH_TOKEN', [NullString]::Value, 'Process') }
|
||||
else { [Environment]::SetEnvironmentVariable('TCLI_AUTH_TOKEN', $oldToken, 'Process') }
|
||||
Pop-Location
|
||||
if ($null -ne $configDir -and (Test-PublishPathWithin $configDir $configBase) -and
|
||||
[IO.Directory]::Exists($configDir) -and
|
||||
(Test-PublishPathWithin (Get-PublishPhysicalPath $configDir) (Get-PublishPhysicalPath $configBase))) {
|
||||
try {
|
||||
if ([IO.File]::Exists($configPath)) { [IO.File]::Delete($configPath) }
|
||||
[IO.Directory]::Delete($configDir, $false)
|
||||
} catch { Write-Warning "Could not remove generated configuration directory: $configDir. Remove it when no longer needed." }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
Invoke-ModPublish -RepositoryRoot $PSScriptRoot -Project $Project -Namespace $Namespace -EnvFile $EnvFile -DryRun:$DryRun
|
||||
} catch {
|
||||
Write-Error -Message $_.Exception.Message -ErrorAction Continue
|
||||
exit 1
|
||||
}
|
||||
Reference in new issue
Block a user