fix(release): make publish reruns safe

Reuse the existing draft release and tagged snapshot, skip already-published packages on retry, and sync dev before undrafting so release reruns stop rewriting history and can recover cleanly from partial failures.

packages/opencode/script/publish.ts

@@ -7,6 +7,20 @@ import { fileURLToPath } from "url"
 const dir = fileURLToPath(new URL("..", import.meta.url))
 process.chdir(dir)
 
+async function published(name: string, version: string) {
+  return (await $`npm view ${name}@${version} version`.nothrow()).exitCode === 0
+}
+
+async function publish(dir: string, name: string, version: string) {
+  if (await published(name, version)) {
+    console.log(`already published ${name}@${version}`)
+    return
+  }
+  if (process.platform !== "win32") await $`chmod -R 755 .`.cwd(dir)
+  await $`bun pm pack`.cwd(dir)
+  await $`npm publish *.tgz --access public --tag ${Script.channel}`.cwd(dir)
+}
+
 const binaries: Record<string, string> = {}
 for (const filepath of new Bun.Glob("*/package.json").scanSync({ cwd: "./dist" })) {
   const pkg = await Bun.file(`./dist/${filepath}`).json()
@@ -40,14 +54,10 @@ await Bun.file(`./dist/${pkg.name}/package.json`).write(
 )
 
 const tasks = Object.entries(binaries).map(async ([name]) => {
-  if (process.platform !== "win32") {
+  await publish(`./dist/${name}`, name, binaries[name])
-    await $`chmod -R 755 .`.cwd(`./dist/${name}`)
-  }
-  await $`bun pm pack`.cwd(`./dist/${name}`)
-  await $`npm publish *.tgz --access public --tag ${Script.channel}`.cwd(`./dist/${name}`)
 })
 await Promise.all(tasks)
-await $`cd ./dist/${pkg.name} && bun pm pack && npm publish *.tgz --access public --tag ${Script.channel}`
+await publish(`./dist/${pkg.name}`, `${pkg.name}-ai`, version)
 
 const image = "ghcr.io/anomalyco/opencode"
 const platforms = "linux/amd64,linux/arm64"
@@ -104,6 +114,7 @@ if (!Script.preview) {
         await Bun.file(`./dist/aur-${pkg}/PKGBUILD`).write(pkgbuild)
         await $`cd ./dist/aur-${pkg} && makepkg --printsrcinfo > .SRCINFO`
         await $`cd ./dist/aur-${pkg} && git add PKGBUILD .SRCINFO`
+        if ((await $`cd ./dist/aur-${pkg} && git diff --cached --quiet`.nothrow()).exitCode === 0) break
         await $`cd ./dist/aur-${pkg} && git commit -m "Update to v${Script.version}"`
         await $`cd ./dist/aur-${pkg} && git push`
         break
@@ -176,6 +187,8 @@ if (!Script.preview) {
   await $`git clone ${tap} ./dist/homebrew-tap`
   await Bun.file("./dist/homebrew-tap/opencode.rb").write(homebrewFormula)
   await $`cd ./dist/homebrew-tap && git add opencode.rb`
-  await $`cd ./dist/homebrew-tap && git commit -m "Update to v${Script.version}"`
+  if ((await $`cd ./dist/homebrew-tap && git diff --cached --quiet`.nothrow()).exitCode !== 0) {
-  await $`cd ./dist/homebrew-tap && git push`
+    await $`cd ./dist/homebrew-tap && git commit -m "Update to v${Script.version}"`
+    await $`cd ./dist/homebrew-tap && git push`
+  }
 }

packages/plugin/script/publish.ts

@@ -6,9 +6,19 @@ import { fileURLToPath } from "url"
 const dir = fileURLToPath(new URL("..", import.meta.url))
 process.chdir(dir)
 
+async function published(name: string, version: string) {
+  return (await $`npm view ${name}@${version} version`.nothrow()).exitCode === 0
+}
+
 await $`bun tsc`
-const pkg = await import("../package.json").then((m) => m.default)
+const pkg = await import("../package.json").then(
+  (m) => m.default as { name: string; version: string; exports: Record<string, string> },
+)
 const original = JSON.parse(JSON.stringify(pkg))
+if (await published(pkg.name, pkg.version)) {
+  console.log(`already published ${pkg.name}@${pkg.version}`)
+  process.exit(0)
+}
 for (const [key, value] of Object.entries(pkg.exports)) {
   const file = value.replace("./src/", "./dist/").replace(".ts", "")
   // @ts-ignore

packages/sdk/js/script/publish.ts

@@ -7,24 +7,35 @@ import { fileURLToPath } from "url"
 const dir = fileURLToPath(new URL("..", import.meta.url))
 process.chdir(dir)
 
+async function published(name: string, version: string) {
+  return (await $`npm view ${name}@${version} version`.nothrow()).exitCode === 0
+}
+
 const pkg = (await import("../package.json").then((m) => m.default)) as {
-  exports: Record<string, string | object>
+  name: string
+  version: string
+  exports: Record<string, unknown>
 }
 const original = JSON.parse(JSON.stringify(pkg))
-function transformExports(exports: Record<string, string | object>) {
+function transformExports(exports: Record<string, unknown>) {
-  for (const [key, value] of Object.entries(exports)) {
+  return Object.fromEntries(
-    if (typeof value === "object" && value !== null) {
+    Object.entries(exports).map(([key, value]) => {
-      transformExports(value as Record<string, string | object>)
+      if (typeof value === "string") {
-    } else if (typeof value === "string") {
+        const file = value.replace("./src/", "./dist/").replace(".ts", "")
-      const file = value.replace("./src/", "./dist/").replace(".ts", "")
+        return [key, { import: file + ".js", types: file + ".d.ts" }]
-      exports[key] = {
-        import: file + ".js",
-        types: file + ".d.ts",
       }
-    }
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-  }
+        return [key, transformExports(value)]
+      }
+      return [key, value]
+    }),
+  )
 }
-transformExports(pkg.exports)
+if (await published(pkg.name, pkg.version)) {
+  console.log(`already published ${pkg.name}@${pkg.version}`)
+  process.exit(0)
+}
+pkg.exports = transformExports(pkg.exports)
 await Bun.write("package.json", JSON.stringify(pkg, null, 2))
 await $`bun pm pack`
 await $`npm publish *.tgz --tag ${Script.channel} --access public`

script/publish.ts

@@ -6,6 +6,9 @@ import { fileURLToPath } from "url"
 
 console.log("=== publishing ===\n")
 
+const tag = `v${Script.version}`
+const release_commit = `release: ${tag}`
+
 const pkgjsons = await Array.fromAsync(
   new Bun.Glob("**/package.json").scan({
     absolute: true,
@@ -14,6 +17,16 @@ const pkgjsons = await Array.fromAsync(
 
 const extensionToml = fileURLToPath(new URL("../packages/extensions/zed/extension.toml", import.meta.url))
 
+async function hasChanges() {
+  return (await $`git diff --quiet && git diff --cached --quiet`.nothrow()).exitCode !== 0
+}
+
+async function releaseTagReady() {
+  const ref = await $`git rev-parse -q --verify refs/tags/${tag}`.nothrow()
+  if (ref.exitCode !== 0) return false
+  return (await $`git log -1 --format=%s refs/tags/${tag}`.text()).trim() === release_commit
+}
+
 async function prepareReleaseFiles() {
   for (const file of pkgjsons) {
     let pkg = await Bun.file(file).text()
@@ -32,21 +45,24 @@ async function prepareReleaseFiles() {
   await $`./packages/sdk/js/script/build.ts`
 }
 
+if (Script.release && !Script.preview) {
+  await $`git fetch origin --tags`
+  if (await releaseTagReady()) await $`git switch --detach refs/tags/${tag}`
+  else await $`git switch --detach`
+}
+
 await prepareReleaseFiles()
 
-if (Script.release) {
+if (Script.release && !Script.preview && !(await releaseTagReady())) {
-  if (!Script.preview) {
+  await $`git commit -am ${release_commit}`
-    await $`git switch --detach`
+  if ((await $`git rev-parse -q --verify refs/tags/${tag}`.nothrow()).exitCode === 0) {
-    await $`git commit -am "release: v${Script.version}"`
+    await $`git tag -f ${tag}`
-    await $`git tag -f v${Script.version}`
+    await $`git push origin refs/tags/${tag} --force --no-verify`
-    await $`git push origin refs/tags/v${Script.version} --force --no-verify`
+  } else {
+    await $`git tag ${tag}`
+    await $`git push origin refs/tags/${tag} --no-verify`
     await new Promise((resolve) => setTimeout(resolve, 5_000))
   }
-
-  await import(`../packages/desktop/scripts/finalize-latest-json.ts`)
-  await import(`../packages/desktop-electron/scripts/finalize-latest-yml.ts`)
-
-  await $`gh release edit v${Script.version} --draft=false --repo ${process.env.GH_REPO}`
 }
 
 console.log("\n=== cli ===\n")
@@ -58,12 +74,25 @@ await import(`../packages/sdk/js/script/publish.ts`)
 console.log("\n=== plugin ===\n")
 await import(`../packages/plugin/script/publish.ts`)
 
+if (Script.release) {
+  await import(`../packages/desktop/scripts/finalize-latest-json.ts`)
+  await import(`../packages/desktop-electron/scripts/finalize-latest-yml.ts`)
+}
+
 if (Script.release && !Script.preview) {
   await $`git fetch origin`
   await $`git checkout -B dev origin/dev`
   await prepareReleaseFiles()
-  await $`git commit -am "sync release versions for v${Script.version}"`
+  if (await hasChanges()) {
-  await $`git push origin HEAD:dev --no-verify`
+    await $`git commit -am "sync release versions for v${Script.version}"`
+    await $`git push origin HEAD:dev --no-verify`
+  } else {
+    console.log(`dev already synced for ${tag}`)
+  }
+}
+
+if (Script.release) {
+  await $`gh release edit ${tag} --draft=false --repo ${process.env.GH_REPO}`
 }
 
 const dir = fileURLToPath(new URL("..", import.meta.url))

script/version.ts

@@ -5,6 +5,33 @@ import { $ } from "bun"
 
 const output = [`version=${Script.version}`]
 const sha = process.env.GITHUB_SHA ?? (await $`git rev-parse HEAD`.text()).trim()
+const repo = process.env.GH_REPO
+
+async function releaseView() {
+  if (repo) return await $`gh release view v${Script.version} --json tagName,databaseId --repo ${repo}`.json()
+  return await $`gh release view v${Script.version} --json tagName,databaseId`.json()
+}
+
+async function ensureRelease(notesFile?: string) {
+  const existing = repo
+    ? await $`gh release view v${Script.version} --json tagName,databaseId --repo ${repo}`.nothrow()
+    : await $`gh release view v${Script.version} --json tagName,databaseId`.nothrow()
+  if (existing.exitCode === 0) return await releaseView()
+  if (notesFile) {
+    if (repo) {
+      await $`gh release create v${Script.version} -d --target ${sha} --title "v${Script.version}" --notes-file ${notesFile} --repo ${repo}`
+      return await releaseView()
+    }
+    await $`gh release create v${Script.version} -d --target ${sha} --title "v${Script.version}" --notes-file ${notesFile}`
+    return await releaseView()
+  }
+  if (repo) {
+    await $`gh release create v${Script.version} -d --target ${sha} --title "v${Script.version}" --repo ${repo}`
+    return await releaseView()
+  }
+  await $`gh release create v${Script.version} -d --target ${sha} --title "v${Script.version}"`
+  return await releaseView()
+}
 
 if (!Script.preview) {
   await $`bun script/changelog.ts --to ${sha}`.cwd(process.cwd())
@@ -15,14 +42,11 @@ if (!Script.preview) {
   const dir = process.env.RUNNER_TEMP ?? "/tmp"
   const notesFile = `${dir}/opencode-release-notes.txt`
   await Bun.write(notesFile, body)
-  await $`gh release create v${Script.version} -d --target ${sha} --title "v${Script.version}" --notes-file ${notesFile}`
+  const release = await ensureRelease(notesFile)
-  const release = await $`gh release view v${Script.version} --json tagName,databaseId`.json()
   output.push(`release=${release.databaseId}`)
   output.push(`tag=${release.tagName}`)
 } else if (Script.channel === "beta") {
-  await $`gh release create v${Script.version} -d --target ${sha} --title "v${Script.version}" --repo ${process.env.GH_REPO}`
+  const release = await ensureRelease()
-  const release =
-    await $`gh release view v${Script.version} --json tagName,databaseId --repo ${process.env.GH_REPO}`.json()
   output.push(`release=${release.databaseId}`)
   output.push(`tag=${release.tagName}`)
 }