- Home
- Skills
- DevOps & Cloud
- InstallTwin — Bash Installers to Native PowerShell
More screenshots
Works with the AI Agents you already use
InstallTwin — Bash Installers to Native PowerShell
InstallTwin helps your connected agent build the native PowerShell sibling from the behavior your project already relies on.
$12
InstallTwin — Bash Installers to Native PowerShell
Example session with this skill installed
CedarCLI Windows installer handoff
This is a fictional maintainer task with synthetic release files. CedarCLI already has a bespoke per-user POSIX installer in install-cedar.sh. We need its native Windows PowerShell sibling so people can use our existing release downloads from PowerShell without Git Bash or WSL.
Please port the actual install, rerun, update and uninstall behavior in this source. Return a readable install-cedar.ps1, a concise explanation of the Windows adaptations, and runnable local rehearsals with the observed outcomes. Preserve our existing source and release fixtures. Do not replace our release process with a new distribution framework or install a separate Bash translation module.
Use native parameter names -Version, -Channel, -InstallRoot, -BaseUrl, -Arch, -NoPath, -PathFile, and -Uninstall corresponding to the source's switches. Preserve the CEDAR_* environment overrides and let explicit parameters take precedence. Our Windows releases are ZIP files, and their executable member is cedar.exe; the POSIX releases are tar.gz files with cedar. The supported Windows architecture names are amd64 and arm64. The downloads use the exact platform names in RELEASE-FACTS.md.
The source's ordinary per-user profile integration needs a Windows adaptation to User-scope PATH, with a restart/current-session explanation. -NoPath must disable both persistent and current-session PATH changes. -PathFile is our local rehearsal adapter: it represents the persistent user PATH as plain UTF-8 text and uses the target platform's separator. It must not touch the real User PATH. Rehearsals must always supply a temporary install root and either -NoPath or -PathFile.
The existing config and unrelated files belong to the user. Work out ownership and failure behavior from the installer source. We particularly care about a failed update leaving the existing installation usable and an uninstall preserving user work. Do not fabricate success for operations the available host cannot execute.
Use the local HTTP release fixtures described below. The Windows .exe fixture members are deliberately inert text bytes; verifying their delivery is a file-operation rehearsal, not evidence that a real Windows binary launches. Report PowerShell parsing, local fixture behavior and any unexecuted Windows integration separately.
No real website publication, user-profile edit, PATH change, application install outside the explicit temporary root, external upload or deployment is authorized by this rehearsal request.
- Read your context and instructions
- Compiled the installtwin
CedarCLI: actual synthetic worked result
This is a fictional maintainer task, not a customer result. A fresh author received only the InstallTwin skill, original Bash source, release facts and harmless fixture files; the hidden outcome checks and other agents' outputs were withheld.
The task was to return a native PowerShell sibling preserving version/channel precedence, custom install root, config retention, unchanged rerun, updates and ownership-aware uninstall, without Git Bash, WSL or a separate translation module.
Delivered result
install-cedar.ps1: readable native PowerShell/.NET source; declared target PowerShell 7.2+, with 7.6.9 actually executed.- Source-linked behavior map, with Windows asset/path/PATH and native argument-binding adaptations explicit.
- Source-specific static fixture builder and a 50-case plan: 42 native cases and 8 source cases.
- Buyer replay runner consuming the same plan, with no dependency on this skill's protected helper.
- Fixed JSON/Markdown observations tied to source, target, plan and helper identities. The packaged helper was run unchanged from a temporary file and removed.
Final authored observation and retained buyer replay: 50/50 cases, 93 steps, 119 file assertions passed; inputs unchanged. The observer directly ran the candidate and source commands and served static fixtures; it did not wrap a second PASS-marker harness.
Independent frozen file-outcome evaluator
25/25 passed on the delivered native source. A separate capable ordinary-agent/free-guidance baseline also passed 25/25; this is no correctness or speed superiority claim. The paid utility demonstrated is reusable rehearsal/evidence mechanics, not a capability unavailable to every plain agent.
A disposable copy with only the archive checksum comparison removed failed the real checksum-update case: expected exit 1 became 0 and old binary/receipt SHA256 assertions failed. The delivered source was unchanged. This establishes detection of that injected fault only.
Exact identities
Supplied Bash SHA256: 7bda2ef8a6a9e00ce9efb85d8147b5c708804f65a616e2a7b9977ba70a1b9d6e
Delivered native SHA256: 1fa4363c9b087442fcc6f547f659cd1d21fd46ad974c458750fee52018d6a7b0
Temporary helper SHA256: 0262f63afd37086a0156e7933dcfe856b1515ab31586a6415d974057431e5a23
Actual failures retained
The author corrected a duplicated native Arch flag and a source-environment setup error. A later direct receipt-schema probe caught a PowerShell numeric-coercion bug accepting string schema"1". The bug was corrected and kept in the final regression plan. These were observed failures, not invented examples.
The parent corrected a macOS /var versus /private/var test-workspace spelling issue equally for the source, baseline and skill outputs, preserving the behavioral cases and original evidence.
Replay and scope
The historical qualification replay used python3 run-replay.py --pwsh <actual-pwsh-path> --out <new-evidence-directory> with the author's retained local demo files. The runner, plan, fixture builder and fixtures are qualification artifacts; they are not members of the skill ZIP. Buyers receive the complete generated native example source and this report summary for inspection. When buyers supply their own project, the agent creates a new source-specific replay suite as a task output. Source-side cases require Bash; the generated native installer itself does not require Python or Bash.
The included cedar-install.ps1 is the actual generated
example output source, retained for inspection, not a universal installer template. It uses a deliberately invalid fictional download hostname and inert fixture payloads. Do not run it against a real user profile or treat it as a real downloadable application. Supply actual project source/assets to use InstallTwin on a different CLI.
Executed: PowerShell 7.6.9 and Python 3.12.9 on macOS 27.2 arm64; real loopback HTTP, archive and file-control-flow cases. Not executed: native Windows, working EXE launch, real persistent User PATH, Windows ACL/locked-EXE behavior, signing, UAC or PowerShell 5.1. Boundary replacements and unexecuted branches are explicit in the actual handoff. No compatibility certification, marketplace-runtime trial, customer purchase or income is claimed.
Complete generated native installer
The following is the full fictional CedarCLI output, without omitted code. The companion replay plan, fixture builder, fixtures and buyer runner were retained locally as qualification artifacts and are not ZIP members. For buyers' own projects, the agent generates new source-specific replay outputs. This is example output, not the protected InstallTwin helper.
#requires -Version 7.2
# Fictional CedarCLI release fixture. Derived from the supplied original; no real vendor is represented.
# Rehearsals require an explicit temporary -InstallRoot and -NoPath or -PathFile.
[CmdletBinding()]
param(
[AllowEmptyString()][string]$Version,
[AllowEmptyString()][string]$Channel,
[AllowEmptyString()][string]$InstallRoot,
[AllowEmptyString()][string]$BaseUrl,
[AllowEmptyString()][string]$Arch,
[switch]$NoPath,
[AllowEmptyString()][string]$PathFile,
[switch]$Uninstall,
[switch]$Help
)
$ErrorActionPreference = 'Stop'
Set-StrictMode -Version Latest
$Utf8 = [Text.UTF8Encoding]::new($false, $true)
$VersionPattern = '\A[0-9]+\.[0-9]+\.[0-9]+(?:-[A-Za-z0-9.-]+)?\z'
function Get-Setting([string]$Name, [string]$Environment, [string]$Default) {
if ($script:PSBoundParameters.ContainsKey($Name)) { return $script:PSBoundParameters[$Name] }
$value = [Environment]::GetEnvironmentVariable($Environment)
if ([string]::IsNullOrEmpty($value)) { return $Default }
return $value
}
function Get-Digest([byte[]]$Bytes) {
$algorithm = [Security.Cryptography.SHA256]::Create()
try { return ([BitConverter]::ToString($algorithm.ComputeHash($Bytes))).Replace('-', '').ToLowerInvariant() }
finally { $algorithm.Dispose() }
}
function Get-Attributes([string]$Path) {
try { return [IO.File]::GetAttributes($Path) }
catch [IO.FileNotFoundException] { return $null }
catch [IO.DirectoryNotFoundException] { return $null }
}
function Assert-Regular([string]$Path) {
$attributes = Get-Attributes $Path
if ($null -eq $attributes) { return }
if (($attributes -band [IO.FileAttributes]::ReparsePoint) -ne 0) { throw "Owned path is a symlink/reparse point: $Path" }
if (($attributes -band [IO.FileAttributes]::Directory) -ne 0) { throw "Owned path is not a regular file: $Path" }
}
function Assert-Directory([string]$Path, [string]$Label) {
$attributes = Get-Attributes $Path
if ($null -eq $attributes) { return }
if (($attributes -band [IO.FileAttributes]::ReparsePoint) -ne 0 -or ($attributes -band [IO.FileAttributes]::Directory) -eq 0) {
throw "$Label must be a real directory"
}
}
function Get-AbsolutePath([string]$Path) {
if ($Path -eq '~') { $Path = [Environment]::GetFolderPath('UserProfile') }
elseif ($Path.StartsWith('~/') -or $Path.StartsWith('~\')) { $Path = [IO.Path]::Combine([Environment]::GetFolderPath('UserProfile'), $Path.Substring(2)) }
if ($Path -eq '') { $Path = (Get-Location).ProviderPath }
return [IO.Path]::GetFullPath($Path, (Get-Location).ProviderPath)
}
function Get-OwnedState {
Assert-Regular $script:Receipt; Assert-Regular $script:Binary; Assert-Regular $script:Config
if ([IO.File]::Exists($script:Receipt)) {
$data = [IO.File]::ReadAllText($script:Receipt, $script:Utf8) | ConvertFrom-Json -AsHashtable
$wanted = @('schema','tool','version','binary','sha256')
if ($data -isnot [Collections.IDictionary] -or $data.Count -ne 5) { throw 'Unrecognized ownership receipt' }
foreach ($key in $wanted) { if (@($data.Keys | Where-Object { $_ -ceq $key }).Count -ne 1) { throw 'Unrecognized ownership receipt' } }
if ($data.schema -isnot [ValueType] -or $data.schema -ne 1 -or $data.tool -cne 'cedar' -or $data.binary -cne 'bin/cedar.exe' -or
$data.version -isnot [string] -or $data.version -cnotmatch $script:VersionPattern -or
$data.sha256 -isnot [string] -or $data.sha256 -cnotmatch '\A[0-9a-f]{64}\z') { throw 'Unrecognized ownership receipt' }
if (-not [IO.File]::Exists($script:Binary) -or (Get-Digest ([IO.File]::ReadAllBytes($script:Binary))) -cne $data.sha256) {
throw 'Owned binary changed or is missing; manual review required'
}
return $data
}
if ([IO.File]::Exists($script:Binary)) { throw 'Refusing to replace an unowned binary' }
return $null
}
function Get-StateFingerprint($State) {
if ($null -eq $State) { return '' }
return ($State | ConvertTo-Json -Compress)
}
function Get-ReleaseBytes([string]$Relative) {
$url = $script:ReleaseBase.TrimEnd('/') + '/' + $Relative
$uri = $null
if (-not [Uri]::TryCreate($url, [UriKind]::Absolute, [ref]$uri) -or
$uri.Scheme -cnotin @('http','https') -or $uri.UserInfo -ne '') { throw 'Release URL must use HTTP(S) without credentials' }
$client = [Net.Http.HttpClient]::new()
$client.Timeout = [TimeSpan]::FromSeconds(15)
$response = $null; $stream = $null; $buffer = [IO.MemoryStream]::new()
try {
$response = $client.GetAsync($uri, [Net.Http.HttpCompletionOption]::ResponseHeadersRead).GetAwaiter().GetResult()
$null = $response.EnsureSuccessStatusCode()
$stream = $response.Content.ReadAsStreamAsync().GetAwaiter().GetResult()
$chunk = [byte[]]::new(65536)
while (($count = $stream.Read($chunk, 0, $chunk.Length)) -gt 0) {
if ($buffer.Length + $count -gt 8MB) { throw 'Release response exceeds fixture limit' }
$buffer.Write($chunk, 0, $count)
}
return ,$buffer.ToArray()
} finally {
if ($null -ne $stream) { $stream.Dispose() }; if ($null -ne $response) { $response.Dispose() }
$buffer.Dispose(); $client.Dispose()
}
}
function Get-Payload([byte[]]$Archive) {
$memory = [IO.MemoryStream]::new($Archive, $false)
$zip = $null
try {
$zip = [IO.Compression.ZipArchive]::new($memory, [IO.Compression.ZipArchiveMode]::Read)
if ($zip.Entries.Count -ne 1) { throw 'Archive must contain exactly the ordinary file cedar.exe' }
$entry = $zip.Entries[0]
$unixType = (($entry.ExternalAttributes -shr 16) -band 0xF000)
$dosDirectory = (($entry.ExternalAttributes -band 0x10) -ne 0)
if ($entry.FullName -cne 'cedar.exe' -or $dosDirectory -or $unixType -notin @(0,0x8000)) {
throw 'Archive must contain exactly the ordinary file cedar.exe'
}
if ($entry.Length -gt 1MB) { throw 'Binary exceeds fixture limit' }
if ($entry.Length -eq 0) { throw 'Empty binary' }
$stream = $entry.Open(); $result = [IO.MemoryStream]::new()
try {
$chunk = [byte[]]::new(65536)
while (($count = $stream.Read($chunk,0,$chunk.Length)) -gt 0) {
if ($result.Length + $count -gt 1MB) { throw 'Binary exceeds fixture limit' }
$result.Write($chunk,0,$count)
}
if ($result.Length -ne $entry.Length) { throw 'Incomplete ZIP member' }
return ,$result.ToArray()
} finally { $stream.Dispose(); $result.Dispose() }
} finally { if ($null -ne $zip) { $zip.Dispose() }; $memory.Dispose() }
}
function Add-PathEntry([string]$Old, [string]$Entry) {
$entries = @($Old.Split(';') | Where-Object { $_ -ne '' })
if (@($entries | Where-Object { [string]::Equals($_,$Entry,[StringComparison]::OrdinalIgnoreCase) }).Count -gt 0) { return $Old }
return (@($Entry) + $entries) -join ';'
}
function Update-UserPath([string]$Entry, [string]$Adapter) {
if ($Adapter -ne '') {
$path = Get-AbsolutePath $Adapter
Assert-Regular $path
$old = if ([IO.File]::Exists($path)) { [IO.File]::ReadAllText($path,$script:Utf8) } else { '' }
$updated = Add-PathEntry $old $Entry
if ($updated -cne $old) {
$null = [IO.Directory]::CreateDirectory([IO.Path]::GetDirectoryName($path))
[IO.File]::WriteAllText($path,$updated,$script:Utf8)
}
} else {
if (-not $IsWindows) { throw 'Real User PATH integration requires Windows; use -NoPath or -PathFile for rehearsals' }
$old = [Environment]::GetEnvironmentVariable('PATH',[EnvironmentVariableTarget]::User)
if ($null -eq $old) { $old = '' }
$updated = Add-PathEntry $old $Entry
if ($updated -cne $old) { [Environment]::SetEnvironmentVariable('PATH',$updated,[EnvironmentVariableTarget]::User) }
}
$processPath = [Environment]::GetEnvironmentVariable('PATH',[EnvironmentVariableTarget]::Process)
if ($null -eq $processPath) { $processPath = '' }
[Environment]::SetEnvironmentVariable('PATH',(Add-PathEntry $processPath $Entry),[EnvironmentVariableTarget]::Process)
Write-Output 'Added Cedar to User PATH (or the supplied PATH fixture) and this installer process. Open a new terminal for other processes; dot-source the script to update the calling PowerShell session.'
}
function Invoke-CedarInstall {
if ($Help) {
Write-Output 'install-cedar.ps1 [-Version latest|VERSION] [-Channel stable|beta] [-InstallRoot DIR] [-BaseUrl URL] [-Arch amd64|arm64] [-NoPath] [-PathFile FIXTURE] [-Uninstall]'
return
}
$requested = Get-Setting 'Version' 'CEDAR_VERSION' 'latest'
$channelName = Get-Setting 'Channel' 'CEDAR_CHANNEL' 'stable'
$defaultRoot = [Environment]::GetFolderPath('LocalApplicationData')
if ([string]::IsNullOrEmpty($defaultRoot)) { $defaultRoot = [IO.Path]::Combine([Environment]::GetFolderPath('UserProfile'),'AppData','Local') }
$rootArgument = Get-Setting 'InstallRoot' 'CEDAR_INSTALL_ROOT' ([IO.Path]::Combine($defaultRoot,'Cedar'))
$script:ReleaseBase = Get-Setting 'BaseUrl' 'CEDAR_BASE_URL' 'https://downloads.example.invalid/cedar'
$architecture = Get-Setting 'Arch' 'CEDAR_ARCH' ''
$pathAdapter = Get-Setting 'PathFile' 'CEDAR_PATH_FILE' ''
if ($architecture -eq '') {
switch ([Runtime.InteropServices.RuntimeInformation]::OSArchitecture.ToString().ToLowerInvariant()) {
'x64' { $architecture = 'amd64' }; 'arm64' { $architecture = 'arm64' }; default { throw 'Unsupported architecture' }
}
}
if ($architecture -cnotin @('amd64','arm64')) { throw "Unsupported architecture: $architecture" }
if ($channelName -cnotin @('stable','beta')) { throw "Unsupported release channel: $channelName" }
if ($requested -cne 'latest' -and $requested -cnotmatch $script:VersionPattern) { throw 'Invalid version' }
$root = Get-AbsolutePath $rootArgument
if ($root.TrimEnd([IO.Path]::DirectorySeparatorChar,[IO.Path]::AltDirectorySeparatorChar) -eq [IO.Path]::GetPathRoot($root).TrimEnd([IO.Path]::DirectorySeparatorChar,[IO.Path]::AltDirectorySeparatorChar)) { throw 'Install root cannot be a filesystem root' }
Assert-Directory $root 'Install root'
$binDir = [IO.Path]::Combine($root,'bin')
$script:Binary = [IO.Path]::Combine($binDir,'cedar.exe')
$script:Receipt = [IO.Path]::Combine($root,'.cedar-owned.json')
$script:Config = [IO.Path]::Combine($root,'config.json')
Assert-Directory $binDir 'bin'
$before = Get-OwnedState
if ($Uninstall) {
if ($null -eq $before) { Write-Output 'Cedar is not owned at this root; nothing removed'; return }
[IO.File]::Delete($script:Binary); [IO.File]::Delete($script:Receipt)
Write-Output 'Removed owned Cedar binary and receipt; configuration and unrelated files preserved'
return
}
if ($requested -ceq 'latest') {
$metadata = $script:Utf8.GetString((Get-ReleaseBytes ('channels/'+$channelName+'.json'))) | ConvertFrom-Json -AsHashtable
if ($metadata -isnot [Collections.IDictionary] -or -not $metadata.Contains('version') -or $metadata.version -isnot [string] -or $metadata.version -cnotmatch $script:VersionPattern) { throw 'Invalid channel metadata' }
$selected = $metadata.version
} else { $selected = $requested }
$asset = "cedar_${selected}_windows_${architecture}.zip"
$archive = Get-ReleaseBytes ($selected+'/'+$asset)
$checksumBytes = Get-ReleaseBytes ($selected+'/checksums.txt')
if (@($checksumBytes | Where-Object { $_ -gt 127 }).Count -gt 0) { throw 'Checksum file must be ASCII' }
$lines = [Text.Encoding]::ASCII.GetString($checksumBytes) -split '\r?\n'
$matching = @($lines | ForEach-Object { $fields = $_.Trim() -split '\s+'; if ($fields.Count -eq 2 -and $fields[1] -ceq $asset) { ,$fields } })
if ($matching.Count -ne 1 -or $matching[0][0] -cnotmatch '\A[0-9a-f]{64}\z') { throw 'Missing or duplicate exact checksum entry' }
if ((Get-Digest $archive) -cne $matching[0][0]) { throw 'Checksum mismatch' }
$payload = Get-Payload $archive
$newReceipt = $script:Utf8.GetBytes('{"binary":"bin/cedar.exe","schema":1,"sha256":"'+(Get-Digest $payload)+'","tool":"cedar","version":"'+$selected+'"}'+"`n")
if ($NoPath -and $null -ne $before -and (Get-Digest ([IO.File]::ReadAllBytes($script:Binary))) -ceq (Get-Digest $payload) -and
[Convert]::ToBase64String([IO.File]::ReadAllBytes($script:Receipt)) -ceq [Convert]::ToBase64String($newReceipt)) {
Write-Output "Cedar $selected is already installed; unchanged"; return
}
$rootExisted = [IO.Directory]::Exists($root); $binExisted = [IO.Directory]::Exists($binDir)
$null = [IO.Directory]::CreateDirectory($root)
$lock = [IO.Path]::Combine($root,'.cedar-install.lock')
# New-Item without -Force rejects an existing lock. Never remove a lock we did not create.
$null = New-Item -ItemType Directory -Path $lock
$stage = $null; $wroteBinary = $false; $wroteReceipt = $false; $madeConfig = $false
$oldBinary = if ($null -ne $before) { [IO.File]::ReadAllBytes($script:Binary) } else { $null }
$oldReceipt = if ($null -ne $before) { [IO.File]::ReadAllBytes($script:Receipt) } else { $null }
try {
if ((Get-StateFingerprint (Get-OwnedState)) -cne (Get-StateFingerprint $before)) { throw 'Ownership changed during download' }
$null = [IO.Directory]::CreateDirectory($binDir)
$stage = [IO.Path]::Combine($root,'.cedar-stage-'+[Guid]::NewGuid().ToString('N'))
$null = [IO.Directory]::CreateDirectory($stage)
$stagedBinary = [IO.Path]::Combine($stage,'cedar.exe'); $stagedReceipt = [IO.Path]::Combine($stage,'receipt.json')
[IO.File]::WriteAllBytes($stagedBinary,$payload); [IO.File]::WriteAllBytes($stagedReceipt,$newReceipt)
[IO.File]::Move($stagedBinary,$script:Binary,$true); $wroteBinary = $true
[IO.File]::Move($stagedReceipt,$script:Receipt,$true); $wroteReceipt = $true
if (-not [IO.File]::Exists($script:Config)) {
$handle = [IO.File]::Open($script:Config,[IO.FileMode]::CreateNew,[IO.FileAccess]::Write,[IO.FileShare]::None)
try { $seed = $script:Utf8.GetBytes('{"theme":"system","telemetry":false}'+"`n"); $handle.Write($seed,0,$seed.Length) } finally { $handle.Dispose() }
$madeConfig = $true
}
if (-not $NoPath) { Update-UserPath $binDir $pathAdapter }
} catch {
if ($wroteBinary) {
if ($null -eq $oldBinary) { [IO.File]::Delete($script:Binary) }
else { $restore = [IO.Path]::Combine($stage,'restore-binary'); [IO.File]::WriteAllBytes($restore,$oldBinary); [IO.File]::Move($restore,$script:Binary,$true) }
}
if ($wroteReceipt) {
if ($null -eq $oldReceipt) { [IO.File]::Delete($script:Receipt) }
else { $restore = [IO.Path]::Combine($stage,'restore-receipt'); [IO.File]::WriteAllBytes($restore,$oldReceipt); [IO.File]::Move($restore,$script:Receipt,$true) }
}
if ($madeConfig) { [IO.File]::Delete($script:Config) }
throw
} finally {
if ($null -ne $stage) { [IO.Directory]::Delete($stage,$true) }
[IO.Directory]::Delete($lock)
if (-not $binExisted) { try { [IO.Directory]::Delete($binDir) } catch {} }
if (-not $rootExisted) { try { [IO.Directory]::Delete($root) } catch {} }
}
Write-Output "Installed Cedar $selected at $script:Binary"
}
try { Invoke-CedarInstall }
catch { [Console]::Error.WriteLine('Cedar install failed: '+$_.Exception.Message); exit 1 }
Connects securely to your tools. The creator never sees your data.
About this skill
Your CLI has a working Bash installer. Windows users still need Git Bash, WSL or a manual download. InstallTwin helps your connected agent build the native PowerShell sibling from the behavior your project already relies on.
Supply the current installer or repository, its sourced helpers, Windows artifact names/layout and intended PowerShell version. The agent returns readable native source, a source-linked behavior map, buyer-specific replay tests and an honest execution handoff. It preserves source-specific version/channel precedence, custom directories, config and owned-file handling, reruns, updates and uninstall when those exist in your source.
The original Python rehearsal helper provides reusable local fixture serving, real interpreter commands, file assertions, input/plan/code identities, bounded logs and fixed JSON/Markdown evidence. It runs unchanged from a temporary file inside your agent session. You do not author a configuration file: the agent derives the plan and cases from your supplied project. Your generated installer, project-specific tests, plan and reports are retained outputs.
This is a focused implementation workflow, not a universal transpiler or an installer execution service. A capable plain agent can perform this job; no correctness or speed advantage is guaranteed. Free manifest generators such as Ingen are useful for ordinary paired installers. InstallTwin focuses on existing bespoke behavior and reusable rehearsal/evidence machinery.
No separate API key, service subscription or account is required. Your connected coding agent needs file/shell tools, Python 3.10+ and the intended PowerShell runtime to execute meaningful rehearsals. Supplied Windows binaries must actually exist. No real machine installation, persistent PATH change, release publication or account mutation is performed by default.
The published demonstration is a fictional CedarCLI source-to-native port using synthetic loopback HTTP releases and inert Windows payload bytes. Actual host and test scope are stated in the full demo; browser review of a report is presentation evidence only.
Not a universal Bash transpiler, security scanner or semantic-equivalence guarantee. Excludes drivers/services/elevation/signing/registry-heavy enterprise installers. Missing Windows builds cannot be invented. PowerShell on macOS/Linux and boundary doubles do not verify native Windows integration or PowerShell 5.1. Test coverage depends on source-derived assertions; hashes establish identity only. Logs can contain local paths and script output. Original readable single-file rehearsal helper is 24,485 bytes, above Agensi’s 20 KB logic recommendation. The included CedarCLI PowerShell file is a generated fictional-tool example for inspection, not a universal installer; running it with valid fixtures can modify its selected destination.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before any payment.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.
Trust & safety
Security scan
Security scan passed 15 days ago
Requires
Permissions
Reads supplied installer/release files and writes separate task outputs. Executes agent-authored inspected rehearsal commands with user authority; this is not an OS sandbox. Helper serves only explicit static fixtures over loopback GET/HEAD. No telemetry/upload/credential collection. Optional public-source reads use the host agent tools. Real persistent PATH/registry, live installs, production releases and account actions require their own task authorization.