oh-my-opencode 4.9.1 → 4.10.0

package/packages/omo-codex/plugin/components/bootstrap/hooks/hooks.json

@@ -0,0 +1,17 @@
+{
+	"hooks": {
+		"SessionStart": [
+			{
+				"hooks": [
+					{
+						"type": "command",
+						"command": "node \"${PLUGIN_ROOT}/components/bootstrap/dist/cli.js\" hook session-start",
+						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\bootstrap.ps1\"",
+						"timeout": 30,
+						"statusMessage": "LazyCodex(4.10.0): Checking Bootstrap Provisioning"
+					}
+				]
+			}
+		]
+	}
+}

package/packages/omo-codex/plugin/components/bootstrap/manifests/ast-grep.json

@@ -0,0 +1,22 @@
+{
+	"name": "ast-grep",
+	"platforms": {
+		"darwin-arm64": {
+			"sha256": "12a870c414c90208f338649b0b53d9659b724b680edaf9da9c151275dad3e41a",
+			"url": "https://github.com/ast-grep/ast-grep/releases/download/0.42.3/app-aarch64-apple-darwin.zip"
+		},
+		"darwin-x64": {
+			"sha256": "af5a04a43c062974634296f692ab93c03755e5b6f33e70e226a434cde1355a1f",
+			"url": "https://github.com/ast-grep/ast-grep/releases/download/0.42.3/app-x86_64-apple-darwin.zip"
+		},
+		"linux-x64": {
+			"sha256": "4191ac4247d183c502778e740a68b7cf45fe477b6423c43b8b8d6e732ba3b333",
+			"url": "https://github.com/ast-grep/ast-grep/releases/download/0.42.3/app-x86_64-unknown-linux-gnu.zip"
+		},
+		"win32-x64": {
+			"sha256": "98acb57edae7a9f9e68657c2cc03ce25b7144bae69621fe7cf2d0492807cb623",
+			"url": "https://github.com/ast-grep/ast-grep/releases/download/0.42.3/app-x86_64-pc-windows-msvc.zip"
+		}
+	},
+	"version": "0.42.3"
+}

package/packages/omo-codex/plugin/components/bootstrap/manifests/node.json

@@ -0,0 +1,10 @@
+{
+	"name": "node",
+	"platforms": {
+		"win32-x64": {
+			"sha256": "edaca9bd58ec8e92037dac4e877d52f6b8f430b81c18b57e264b4e2fb111cd56",
+			"url": "https://nodejs.org/dist/v24.16.0/node-v24.16.0-win-x64.zip"
+		}
+	},
+	"version": "24.16.0"
+}

package/packages/omo-codex/plugin/components/bootstrap/package.json

@@ -0,0 +1,20 @@
+{
+	"name": "@sisyphuslabs/codex-bootstrap",
+	"version": "4.10.0",
+	"description": "Codex SessionStart bootstrap component that provisions LazyCodex runtime dependencies from a detached worker.",
+	"type": "module",
+	"private": true,
+	"files": [
+		"dist",
+		"hooks",
+		"scripts",
+		"manifests"
+	],
+	"scripts": {
+		"build": "node scripts/build.mjs",
+		"test": "bun test test/*.test.ts"
+	},
+	"engines": {
+		"node": ">=20.0.0"
+	}
+}

package/packages/omo-codex/plugin/components/bootstrap/scripts/bootstrap.ps1

@@ -0,0 +1,310 @@
+# LazyCodex bootstrap SessionStart hook for native Windows (Windows PowerShell 5.1).
+# Codex runs hooks through %COMSPEC%, so node may be absent from PATH entirely;
+# this script provisions it silently: node on PATH -> common install dirs ->
+# winget OpenJS.NodeJS.LTS -> portable ZIP pinned by manifests/node.json
+# (sha256-verified, extracted under <codexHome>\runtime\node, USER PATH append).
+# Git Bash is prepared best-effort on the provisioning path, then the script
+# delegates to the bundled node hook. It always exits 0: provisioning failures
+# are logged to $env:PLUGIN_DATA\bootstrap\ps-bootstrap.log, never block a session.
+
+$ErrorActionPreference = "Continue"
+[Net.ServicePointManager]::SecurityProtocol = [Net.ServicePointManager]::SecurityProtocol -bor [Net.SecurityProtocolType]::Tls12
+
+$script:LogPath = $null
+$script:DoctorHint = "npx lazycodex-ai doctor"
+$script:NonGitBashLauncherDirSegments = @("\windows\system32\", "\microsoft\windowsapps\")
+
+function Initialize-BootstrapLog {
+	if ([string]::IsNullOrWhiteSpace($env:PLUGIN_DATA)) { return }
+	try {
+		$logDirectory = Join-Path $env:PLUGIN_DATA "bootstrap"
+		if (-not (Test-Path -LiteralPath $logDirectory)) {
+			New-Item -ItemType Directory -Path $logDirectory -Force | Out-Null
+		}
+		$script:LogPath = Join-Path $logDirectory "ps-bootstrap.log"
+	} catch {
+		$script:LogPath = $null
+	}
+}
+
+function Write-BootstrapLog {
+	param([string]$Message)
+	if ($null -eq $script:LogPath) { return }
+	try {
+		$stamp = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
+		Add-Content -LiteralPath $script:LogPath -Value ($stamp + " " + $Message) -Encoding ASCII
+	} catch { }
+}
+
+function Resolve-CodexHome {
+	if (-not [string]::IsNullOrWhiteSpace($env:CODEX_HOME)) { return $env:CODEX_HOME.Trim() }
+	if (-not [string]::IsNullOrWhiteSpace($env:PLUGIN_ROOT)) {
+		$current = $env:PLUGIN_ROOT
+		for ($level = 0; $level -lt 6; $level += 1) {
+			$parent = Split-Path -Path $current -Parent
+			if ([string]::IsNullOrEmpty($parent) -or ($parent -eq $current)) { break }
+			$current = $parent
+			if (Test-Path -LiteralPath (Join-Path $current "config.toml") -PathType Leaf) { return $current }
+		}
+	}
+	return (Join-Path $env:USERPROFILE ".codex")
+}
+
+function Get-NodeManifest {
+	$manifestPath = Join-Path $env:PLUGIN_ROOT "components\bootstrap\manifests\node.json"
+	if (-not (Test-Path -LiteralPath $manifestPath -PathType Leaf)) {
+		Write-BootstrapLog ("degraded component=node reason=manifest-missing path=" + $manifestPath + " hint=" + $script:DoctorHint)
+		return $null
+	}
+	try {
+		return (Get-Content -LiteralPath $manifestPath -Raw | ConvertFrom-Json)
+	} catch {
+		Write-BootstrapLog ("degraded component=node reason=manifest-unparsable path=" + $manifestPath + " hint=" + $script:DoctorHint)
+		return $null
+	}
+}
+
+function Get-PortableNodeDirectory {
+	param([string]$CodexHome, $Manifest)
+	$runtimeRoot = Join-Path $CodexHome "runtime\node"
+	return (Join-Path $runtimeRoot ("node-v" + $Manifest.version + "-win-x64"))
+}
+
+function Resolve-NodeCommand {
+	param([string]$CodexHome, $Manifest)
+	$onPath = Get-Command node -CommandType Application -ErrorAction SilentlyContinue
+	if ($null -ne $onPath) {
+		return (@($onPath)[0]).Source
+	}
+	$candidateDirectories = @()
+	if (-not [string]::IsNullOrWhiteSpace($env:ProgramFiles)) {
+		$candidateDirectories += (Join-Path $env:ProgramFiles "nodejs")
+	}
+	if (-not [string]::IsNullOrWhiteSpace($env:LOCALAPPDATA)) {
+		$candidateDirectories += (Join-Path $env:LOCALAPPDATA "Programs\nodejs")
+	}
+	if ($null -ne $Manifest) {
+		$candidateDirectories += (Get-PortableNodeDirectory -CodexHome $CodexHome -Manifest $Manifest)
+	}
+	foreach ($directory in $candidateDirectories) {
+		$candidate = Join-Path $directory "node.exe"
+		if (Test-Path -LiteralPath $candidate -PathType Leaf) { return $candidate }
+	}
+	return $null
+}
+
+function Install-NodeWithWinget {
+	$winget = Get-Command winget -ErrorAction SilentlyContinue
+	if ($null -eq $winget) {
+		Write-BootstrapLog "winget unavailable; skipping winget node install"
+		return
+	}
+	Write-BootstrapLog "installing node via: winget install OpenJS.NodeJS.LTS --silent"
+	try {
+		& winget install OpenJS.NodeJS.LTS --silent --accept-package-agreements --accept-source-agreements | Out-Null
+		Write-BootstrapLog ("winget node install finished with exit code " + $LASTEXITCODE)
+	} catch {
+		Write-BootstrapLog ("winget node install failed: " + $_.Exception.Message)
+	}
+}
+
+function Add-UserPathEntry {
+	param([string]$Directory)
+	$normalizedTarget = $Directory.TrimEnd("\")
+	$currentPath = [Environment]::GetEnvironmentVariable("Path", "User")
+	if ($null -eq $currentPath) { $currentPath = "" }
+	foreach ($entry in $currentPath.Split(";")) {
+		if ($entry.Trim().TrimEnd("\") -eq $normalizedTarget) {
+			Write-BootstrapLog ("user PATH already contains " + $Directory + "; leaving it unchanged")
+			return
+		}
+	}
+	if ($currentPath.Trim().Length -eq 0) {
+		$updatedPath = $Directory
+	} else {
+		$updatedPath = $currentPath.TrimEnd(";") + ";" + $Directory
+	}
+	[Environment]::SetEnvironmentVariable("Path", $updatedPath, "User")
+	Write-BootstrapLog ("appended " + $Directory + " to the USER PATH; restart Codex so new sessions can see node")
+}
+
+function Install-PortableNode {
+	param([string]$CodexHome, $Manifest)
+	if ($null -eq $Manifest) { return $null }
+	$platformEntry = $Manifest.platforms."win32-x64"
+	if ($null -eq $platformEntry) {
+		Write-BootstrapLog ("degraded component=node reason=manifest-missing-win32-x64 hint=" + $script:DoctorHint)
+		return $null
+	}
+	$zipPath = Join-Path $env:TEMP ("lazycodex-node-v" + $Manifest.version + "-win-x64.zip")
+	Write-BootstrapLog ("downloading portable node from " + $platformEntry.url)
+	try {
+		Invoke-WebRequest -Uri $platformEntry.url -OutFile $zipPath -UseBasicParsing
+	} catch {
+		Write-BootstrapLog ("degraded component=node reason=download-failed url=" + $platformEntry.url + " error=" + $_.Exception.Message + " hint=" + $script:DoctorHint)
+		return $null
+	}
+	$expectedHash = ([string]$platformEntry.sha256).ToLowerInvariant()
+	$actualHash = (Get-FileHash -LiteralPath $zipPath -Algorithm SHA256).Hash.ToLowerInvariant()
+	if ($actualHash -ne $expectedHash) {
+		Remove-Item -LiteralPath $zipPath -Force -ErrorAction SilentlyContinue
+		Write-BootstrapLog ("degraded component=node reason=sha256-mismatch expected=" + $expectedHash + " actual=" + $actualHash + " hint=" + $script:DoctorHint)
+		return $null
+	}
+	$runtimeRoot = Join-Path $CodexHome "runtime\node"
+	try {
+		if (-not (Test-Path -LiteralPath $runtimeRoot)) {
+			New-Item -ItemType Directory -Path $runtimeRoot -Force | Out-Null
+		}
+		Expand-Archive -LiteralPath $zipPath -DestinationPath $runtimeRoot -Force
+	} catch {
+		Write-BootstrapLog ("degraded component=node reason=extract-failed error=" + $_.Exception.Message + " hint=" + $script:DoctorHint)
+		return $null
+	} finally {
+		Remove-Item -LiteralPath $zipPath -Force -ErrorAction SilentlyContinue
+	}
+	$nodeDirectory = Get-PortableNodeDirectory -CodexHome $CodexHome -Manifest $Manifest
+	$nodeExe = Join-Path $nodeDirectory "node.exe"
+	if (-not (Test-Path -LiteralPath $nodeExe -PathType Leaf)) {
+		Write-BootstrapLog ("degraded component=node reason=extracted-layout-unexpected expected=" + $nodeExe + " hint=" + $script:DoctorHint)
+		return $null
+	}
+	Write-BootstrapLog ("portable node provisioned at " + $nodeExe)
+	Add-UserPathEntry -Directory $nodeDirectory
+	return $nodeExe
+}
+
+function Test-KnownNonGitBashLauncher {
+	param([string]$CandidatePath)
+	$normalized = $CandidatePath.Replace("/", "\").ToLowerInvariant()
+	foreach ($segment in $script:NonGitBashLauncherDirSegments) {
+		if ($normalized.Contains($segment)) { return $true }
+	}
+	return $false
+}
+
+function Resolve-GitBash {
+	if (-not [string]::IsNullOrWhiteSpace($env:OMO_CODEX_GIT_BASH_PATH)) {
+		$envCandidate = $env:OMO_CODEX_GIT_BASH_PATH.Trim()
+		if ($envCandidate.ToLowerInvariant().EndsWith("bash.exe") -and (Test-Path -LiteralPath $envCandidate -PathType Leaf)) {
+			return @{ Path = $envCandidate; Source = "env" }
+		}
+		return $null
+	}
+	$programFilesCandidates = @()
+	if (-not [string]::IsNullOrWhiteSpace($env:ProgramFiles)) {
+		$programFilesCandidates += (Join-Path $env:ProgramFiles "Git\bin\bash.exe")
+	}
+	$programFilesX86 = ${env:ProgramFiles(x86)}
+	if (-not [string]::IsNullOrWhiteSpace($programFilesX86)) {
+		$programFilesCandidates += (Join-Path $programFilesX86 "Git\bin\bash.exe")
+	}
+	foreach ($candidate in $programFilesCandidates) {
+		if (Test-Path -LiteralPath $candidate -PathType Leaf) {
+			return @{ Path = $candidate; Source = "program-files" }
+		}
+	}
+	$whereOutput = @()
+	try { $whereOutput = & where.exe bash 2>$null } catch { $whereOutput = @() }
+	foreach ($rawLine in @($whereOutput)) {
+		if ($null -eq $rawLine) { continue }
+		$candidate = ([string]$rawLine).Trim()
+		if ($candidate.Length -eq 0) { continue }
+		if (Test-KnownNonGitBashLauncher -CandidatePath $candidate) { continue }
+		if ($candidate.ToLowerInvariant().EndsWith("bash.exe") -and (Test-Path -LiteralPath $candidate -PathType Leaf)) {
+			return @{ Path = $candidate; Source = "path" }
+		}
+	}
+	return $null
+}
+
+function Initialize-GitBash {
+	$resolution = Resolve-GitBash
+	if (($null -eq $resolution) -and ($env:OMO_CODEX_SKIP_GIT_BASH_AUTO_INSTALL -ne "1")) {
+		$winget = Get-Command winget -ErrorAction SilentlyContinue
+		if ($null -ne $winget) {
+			Write-BootstrapLog "installing git bash via: winget install --id Git.Git -e --source winget"
+			try {
+				& winget install --id Git.Git -e --source winget | Out-Null
+				Write-BootstrapLog ("winget git install finished with exit code " + $LASTEXITCODE)
+			} catch {
+				Write-BootstrapLog ("winget git install failed: " + $_.Exception.Message)
+			}
+			$resolution = Resolve-GitBash
+		} else {
+			Write-BootstrapLog "winget unavailable; skipping git bash install"
+		}
+	}
+	if ($null -eq $resolution) {
+		Write-BootstrapLog ("degraded component=git_bash reason=not-found install=winget install --id Git.Git -e --source winget hint=" + $script:DoctorHint)
+		return
+	}
+	Write-BootstrapLog ("git bash resolved at " + $resolution.Path + " source=" + $resolution.Source)
+	if ($resolution.Source -eq "path") {
+		$persisted = [Environment]::GetEnvironmentVariable("OMO_CODEX_GIT_BASH_PATH", "User")
+		if ([string]::IsNullOrWhiteSpace($persisted)) {
+			[Environment]::SetEnvironmentVariable("OMO_CODEX_GIT_BASH_PATH", $resolution.Path, "User")
+			Write-BootstrapLog ("persisted OMO_CODEX_GIT_BASH_PATH=" + $resolution.Path + " in the USER environment; restart Codex to pick it up")
+		}
+	}
+}
+
+function Invoke-NodeHookDelegate {
+	param([string]$NodeExe)
+	$hookCli = Join-Path $env:PLUGIN_ROOT "components\bootstrap\dist\cli.js"
+	if (-not (Test-Path -LiteralPath $hookCli -PathType Leaf)) {
+		Write-BootstrapLog ("degraded component=bootstrap reason=hook-cli-missing path=" + $hookCli + " hint=" + $script:DoctorHint)
+		return
+	}
+	Write-BootstrapLog ("delegating to node hook: " + $NodeExe + " " + $hookCli + " hook session-start")
+	& $NodeExe $hookCli hook session-start
+	Write-BootstrapLog ("node hook exited with code " + $LASTEXITCODE)
+}
+
+function Write-ProvisioningIncompleteNotice {
+	$notice = "LazyCodex bootstrap: Node.js is not available yet. Install Node LTS (winget install OpenJS.NodeJS.LTS), then restart Codex. Diagnose with: " + $script:DoctorHint
+	$payload = @{
+		hookSpecificOutput = @{
+			hookEventName = "SessionStart"
+			additionalContext = $notice
+		}
+	}
+	Write-Output (ConvertTo-Json -InputObject $payload -Compress -Depth 4)
+}
+
+function Invoke-Bootstrap {
+	Initialize-BootstrapLog
+	Write-BootstrapLog "bootstrap.ps1 session-start begin"
+	if ([string]::IsNullOrWhiteSpace($env:PLUGIN_ROOT)) {
+		Write-BootstrapLog "PLUGIN_ROOT missing; skipping bootstrap"
+		return
+	}
+	$codexHome = Resolve-CodexHome
+	Write-BootstrapLog ("codex home resolved to " + $codexHome)
+	$manifest = Get-NodeManifest
+	$nodeExe = Resolve-NodeCommand -CodexHome $codexHome -Manifest $manifest
+	if ($null -ne $nodeExe) {
+		Write-BootstrapLog ("node already available at " + $nodeExe)
+		Invoke-NodeHookDelegate -NodeExe $nodeExe
+		return
+	}
+	Install-NodeWithWinget
+	$nodeExe = Resolve-NodeCommand -CodexHome $codexHome -Manifest $manifest
+	if ($null -eq $nodeExe) {
+		$nodeExe = Install-PortableNode -CodexHome $codexHome -Manifest $manifest
+	}
+	Initialize-GitBash
+	if ($null -eq $nodeExe) {
+		Write-BootstrapLog ("degraded component=node reason=unresolved hint=" + $script:DoctorHint)
+		Write-ProvisioningIncompleteNotice
+		return
+	}
+	Invoke-NodeHookDelegate -NodeExe $nodeExe
+}
+
+try {
+	Invoke-Bootstrap
+} catch {
+	try { Write-BootstrapLog ("unhandled bootstrap error: " + $_.Exception.Message) } catch { }
+}
+exit 0

package/packages/omo-codex/plugin/components/bootstrap/scripts/build.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { existsSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const componentRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+const bundlePath = join(componentRoot, "dist", "cli.js");
+
+const result = spawnSync(
+	"bun",
+	["x", "esbuild", "src/cli.ts", "--bundle", "--platform=node", "--format=esm", "--outfile=dist/cli.js"],
+	{
+		cwd: componentRoot,
+		shell: process.platform === "win32",
+		stdio: "inherit",
+	},
+);
+
+if (result.error === undefined && result.status === 0) {
+	process.exit(0);
+}
+
+if (hasBundledDist()) {
+	console.log("Using bundled bootstrap dist");
+	process.exit(0);
+}
+
+console.error(`Bootstrap bundle failed and no bundled dist exists at ${bundlePath}.`);
+console.error("Install Bun (used via `bun x esbuild`) or ship a prebuilt dist/cli.js.");
+process.exit(result.status === null || result.status === undefined || result.status === 0 ? 1 : result.status);
+
+function hasBundledDist() {
+	return existsSync(bundlePath) && statSync(bundlePath).size > 0;
+}

package/packages/omo-codex/plugin/components/bootstrap/scripts/generate-manifests.mjs

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+// Regenerates the committed, reviewed manifests at ../manifests/{ast-grep,node}.json.
+// This script is the ONLY network-touching code in the bootstrap component; runtime
+// downloads consume the pinned values, and unit tests inject fetch (never the network).
+//
+// Re-run procedure (after an @ast-grep/cli bump in packages/ast-grep-mcp/package.json,
+// or to move the pinned Node.js LTS):
+//   1. bun install (so node_modules/@ast-grep/cli matches the lockfile resolution)
+//   2. node packages/omo-codex/plugin/components/bootstrap/scripts/generate-manifests.mjs
+//      [--ast-grep-version <x.y.z>] [--node-version <x.y.z>]
+//   3. Review the manifest diff and commit it. Manifests are NEVER generated at build
+//      time; builds must stay offline and deterministic.
+//
+// Sources:
+//   - sg:   https://github.com/ast-grep/ast-grep/releases (assets downloaded + hashed
+//           here because the release publishes no checksum files)
+//   - node: https://nodejs.org/dist (SHASUMS256.txt per release; win32-x64 zip only)
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const scriptDirectory = dirname(fileURLToPath(import.meta.url));
+const componentRoot = dirname(scriptDirectory);
+const repoRoot = resolve(componentRoot, "..", "..", "..", "..", "..");
+const manifestsDirectory = join(componentRoot, "manifests");
+
+const SG_PLATFORM_ASSETS = {
+	"darwin-arm64": "app-aarch64-apple-darwin.zip",
+	"darwin-x64": "app-x86_64-apple-darwin.zip",
+	"linux-x64": "app-x86_64-unknown-linux-gnu.zip",
+	"win32-x64": "app-x86_64-pc-windows-msvc.zip",
+};
+
+function parseArgs(argv) {
+	const flags = {};
+	for (let index = 0; index < argv.length; index += 1) {
+		if (argv[index] === "--ast-grep-version") flags.astGrepVersion = argv[(index += 1)];
+		else if (argv[index] === "--node-version") flags.nodeVersion = argv[(index += 1)];
+		else throw new Error(`unknown argument: ${argv[index]}`);
+	}
+	return flags;
+}
+
+async function fetchOk(url, accept) {
+	const headers = { "user-agent": "lazycodex-generate-manifests" };
+	if (accept) headers.accept = accept;
+	if (process.env.GITHUB_TOKEN && url.startsWith("https://api.github.com/")) {
+		headers.authorization = `Bearer ${process.env.GITHUB_TOKEN}`;
+	}
+	const response = await fetch(url, { headers });
+	if (!response.ok) throw new Error(`GET ${url} -> HTTP ${response.status}`);
+	return response;
+}
+
+async function resolveInstalledAstGrepVersion() {
+	const declared = JSON.parse(await readFile(join(repoRoot, "packages", "ast-grep-mcp", "package.json"), "utf8"))
+		.dependencies["@ast-grep/cli"];
+	const installedPackageJsonPath = join(repoRoot, "node_modules", "@ast-grep", "cli", "package.json");
+	const installed = JSON.parse(await readFile(installedPackageJsonPath, "utf8")).version;
+	console.log(`ast-grep: declared ${declared} in packages/ast-grep-mcp, locked install ${installed}`);
+	return installed;
+}
+
+async function generateAstGrepManifest(version) {
+	const release = await (
+		await fetchOk(`https://api.github.com/repos/ast-grep/ast-grep/releases/tags/${version}`, "application/vnd.github+json")
+	).json();
+	const assetNames = new Set(release.assets.map((asset) => asset.name));
+	const platforms = {};
+	for (const [platformKey, assetName] of Object.entries(SG_PLATFORM_ASSETS)) {
+		if (!assetNames.has(assetName)) {
+			throw new Error(`release ${version} has no asset named ${assetName} (have: ${[...assetNames].join(", ")})`);
+		}
+		const url = `https://github.com/ast-grep/ast-grep/releases/download/${version}/${assetName}`;
+		const bytes = Buffer.from(await (await fetchOk(url)).arrayBuffer());
+		const sha256 = createHash("sha256").update(bytes).digest("hex");
+		platforms[platformKey] = { sha256, url };
+		console.log(`ast-grep ${platformKey}: ${assetName} ${bytes.length} bytes sha256=${sha256}`);
+	}
+	return { name: "ast-grep", platforms, version };
+}
+
+async function resolveLatestNodeLtsVersion() {
+	const releases = await (await fetchOk("https://nodejs.org/dist/index.json")).json();
+	const latestLts = releases.find((release) => release.lts !== false);
+	if (latestLts === undefined) throw new Error("nodejs.org/dist/index.json contains no LTS release");
+	console.log(`node: latest LTS ${latestLts.version} (${latestLts.lts})`);
+	return latestLts.version.replace(/^v/, "");
+}
+
+async function generateNodeManifest(version) {
+	const zipName = `node-v${version}-win-x64.zip`;
+	const shasums = await (await fetchOk(`https://nodejs.org/dist/v${version}/SHASUMS256.txt`)).text();
+	const line = shasums.split("\n").find((candidate) => candidate.trim().endsWith(`  ${zipName}`) || candidate.trim().endsWith(` ${zipName}`));
+	if (line === undefined) throw new Error(`SHASUMS256.txt for v${version} has no entry for ${zipName}`);
+	const sha256 = line.trim().split(/\s+/)[0];
+	if (!/^[a-f0-9]{64}$/.test(sha256)) throw new Error(`invalid sha256 parsed for ${zipName}: ${sha256}`);
+	const url = `https://nodejs.org/dist/v${version}/${zipName}`;
+	console.log(`node win32-x64: ${zipName} sha256=${sha256}`);
+	return { name: "node", platforms: { "win32-x64": { sha256, url } }, version };
+}
+
+async function writeManifest(fileName, manifest) {
+	const path = join(manifestsDirectory, fileName);
+	await mkdir(manifestsDirectory, { recursive: true });
+	await writeFile(path, `${JSON.stringify(manifest, null, "\t")}\n`, "utf8");
+	console.log(`wrote ${path}`);
+}
+
+const flags = parseArgs(process.argv.slice(2));
+const astGrepVersion = flags.astGrepVersion ?? (await resolveInstalledAstGrepVersion());
+const nodeVersion = flags.nodeVersion ?? (await resolveLatestNodeLtsVersion());
+await writeManifest("ast-grep.json", await generateAstGrepManifest(astGrepVersion));
+await writeManifest("node.json", await generateNodeManifest(nodeVersion));