code-foundry 1.12.0 → 1.13.0

package/src/commands/fleet.mjs

@@ -1,15 +1,21 @@
 // @ts-check
 
-import { existsSync, mkdtempSync, readFileSync, readdirSync, writeFileSync } from 'node:fs'
+import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { tmpdir } from 'node:os'
 import { spawnSync } from 'node:child_process'
 import { readPackageVersion, syncRepository } from './sync.mjs'
+import {
+  discoverManifestRepositories,
+  hasFleetManifest,
+  upgradeManifestFleet,
+} from '../lib/fleet-manifest.mjs'
 
 /** @typedef {{ path: string, repository: string, runtimeRef: string, dirty: boolean, configured: boolean, gitWorkflow: string }} FleetRepository */
 
 /** @param {string} root @returns {FleetRepository[]} */
 export function discoverRepositories(root) {
+  if (hasFleetManifest(root)) return discoverManifestRepositories(root)
   /** @type {FleetRepository[]} */
   const result = []
   const candidates = [root, ...children(root), ...children(join(root, 'NiftyLeague'))]
@@ -39,6 +45,8 @@ export function upgradeFleet(root, source, options) {
       `fleet upgrade target ${options.version} does not match the runtime source checkout (${sourceVersion}); refresh the code-foundry checkout to ${options.version} before upgrading so the rendered callers and the declared runtime agree.`
     )
   }
+  if (hasFleetManifest(root))
+    return upgradeManifestFleet(root, source, { ...options, version }, syncRepository)
   const repositories = discoverRepositories(root)
   const report = []
   for (const repository of repositories) {
@@ -98,6 +106,7 @@ function upgradeRepository(repository, source, version) {
   const branch = `codex/code-foundry-upgrade-${version.replace(/^v/, '')}`
   const base = repository.gitWorkflow === 'staging-release' ? 'staging' : 'main'
   const temporary = mkdtempSync(join(tmpdir(), 'code-foundry-fleet-'))
+  let attached = false
   try {
     const fetch = spawnSync('git', ['-C', repository.path, 'fetch', 'origin', base, '--quiet'], {
       encoding: 'utf8',
@@ -108,6 +117,48 @@ function upgradeRepository(repository, source, version) {
         status: 'skipped',
         reason: fetch.stderr.trim() || `unable to refresh ${base} baseline`,
       }
+    const marker = `<!-- code-foundry-legacy-rollout:${repository.repository}:${version}:${base} -->`
+    const commitMarker = `Code-Foundry-Legacy-Rollout: ${repository.repository}:${version}:${base}`
+    const remoteBranch = spawnSync(
+      'git',
+      ['-C', repository.path, 'ls-remote', '--heads', 'origin', `refs/heads/${branch}`],
+      { encoding: 'utf8' }
+    )
+    if (remoteBranch.status !== 0)
+      return {
+        path: repository.path,
+        status: 'failed',
+        branch,
+        reason: remoteBranch.stderr.trim() || 'unable to inspect existing upgrade branch',
+      }
+    const remote = remoteBranch.stdout.trim().split(/\s/)[0] ?? ''
+    const local = spawnSync(
+      'git',
+      ['-C', repository.path, 'rev-parse', '--verify', '--quiet', `refs/heads/${branch}`],
+      { encoding: 'utf8' }
+    )
+    if (local.status !== 0 && local.status !== 1)
+      return {
+        path: repository.path,
+        status: 'failed',
+        branch,
+        reason: 'unable to inspect existing local upgrade branch',
+      }
+    const existing = remote || (local.status === 0 ? local.stdout.trim() : '')
+    if (remote) {
+      const branchFetch = spawnSync(
+        'git',
+        ['-C', repository.path, 'fetch', 'origin', branch, '--quiet'],
+        { encoding: 'utf8' }
+      )
+      if (branchFetch.status !== 0)
+        return {
+          path: repository.path,
+          status: 'failed',
+          branch,
+          reason: branchFetch.stderr.trim() || 'unable to fetch existing upgrade branch',
+        }
+    }
     const baseline = spawnSync('git', ['-C', repository.path, 'rev-parse', `origin/${base}`], {
       encoding: 'utf8',
     })
@@ -117,9 +168,47 @@ function upgradeRepository(repository, source, version) {
         status: 'skipped',
         reason: `remote ${base} branch is unavailable`,
       }
+    if (existing) {
+      const message = spawnSync(
+        'git',
+        ['-C', repository.path, 'show', '-s', '--format=%B', existing],
+        { encoding: 'utf8' }
+      )
+      const tree = spawnSync('git', ['-C', repository.path, 'rev-parse', `${existing}^{tree}`], {
+        encoding: 'utf8',
+      })
+      const parent = spawnSync('git', ['-C', repository.path, 'rev-parse', `${existing}^`], {
+        encoding: 'utf8',
+      })
+      const subject = message.stdout.split(/\r?\n/, 1)[0]
+      const managed =
+        message.status === 0 &&
+        tree.status === 0 &&
+        message.stdout.includes(commitMarker) &&
+        message.stdout.includes(`Code-Foundry-Tree: ${tree.stdout.trim()}`)
+      const legacyManaged =
+        subject === `chore(code-foundry): upgrade runtime to ${version}` &&
+        parent.status === 0 &&
+        parent.stdout.trim() === baseline.stdout.trim()
+      if (!managed && !legacyManaged)
+        return {
+          path: repository.path,
+          status: 'failed',
+          branch,
+          reason: 'Existing upgrade branch is not a managed rollout; reconcile it manually',
+        }
+    }
     const add = spawnSync(
       'git',
-      ['-C', repository.path, 'worktree', 'add', '-b', branch, temporary, baseline.stdout.trim()],
+      [
+        '-C',
+        repository.path,
+        'worktree',
+        'add',
+        '--detach',
+        temporary,
+        existing || baseline.stdout.trim(),
+      ],
       { encoding: 'utf8' }
     )
     if (add.status !== 0)
@@ -128,51 +217,219 @@ function upgradeRepository(repository, source, version) {
         status: 'skipped',
         reason: add.stderr.trim() || 'unable to create isolated worktree',
       }
-    const result = syncRepository({
-      target: temporary,
-      source,
-      force: false,
-      runtimeRef: version,
-    })
-    const configFile = join(temporary, '.github/code-foundry.yml')
-    if (existsSync(configFile)) {
-      const current = readFileSync(configFile, 'utf8')
-      const updated = current.match(/^runtime_ref:\s*.*$/m)
-        ? current.replace(/^runtime_ref:\s*.*$/m, `runtime_ref: ${version}`)
-        : `${current.trimEnd()}\nruntime_ref: ${version}\n`
-      if (updated !== current) {
-        writeFileSync(configFile, updated)
-        if (!result.changed.includes('.github/code-foundry.yml'))
-          result.changed.push('.github/code-foundry.yml')
+    attached = true
+    let validatedHead = existing
+    if (!existing) {
+      const result = syncRepository({
+        target: temporary,
+        source,
+        force: false,
+        runtimeRef: version,
+      })
+      const configFile = join(temporary, '.github/code-foundry.yml')
+      if (existsSync(configFile)) {
+        const current = readFileSync(configFile, 'utf8')
+        const updated = current.match(/^runtime_ref:\s*.*$/m)
+          ? current.replace(/^runtime_ref:\s*.*$/m, `runtime_ref: ${version}`)
+          : `${current.trimEnd()}\nruntime_ref: ${version}\n`
+        if (updated !== current) {
+          writeFileSync(configFile, updated)
+          if (!result.changed.includes('.github/code-foundry.yml'))
+            result.changed.push('.github/code-foundry.yml')
+        }
       }
+      if (!result.changed.length) return { path: repository.path, status: 'unchanged', branch }
+      const stage = spawnSync('git', ['-C', temporary, 'add', '--', ...result.changed], {
+        encoding: 'utf8',
+      })
+      if (stage.status !== 0)
+        return {
+          path: repository.path,
+          status: 'failed',
+          branch,
+          reason: stage.stderr.trim() || 'unable to stage generated upgrade files',
+        }
+      const staged = spawnSync('git', ['-C', temporary, 'diff', '--cached', '--name-only'], {
+        encoding: 'utf8',
+      })
+      if (staged.status !== 0 || !staged.stdout.trim())
+        return { path: repository.path, status: 'unchanged', branch }
+      const tree = spawnSync('git', ['-C', temporary, 'write-tree'], { encoding: 'utf8' })
+      if (tree.status !== 0)
+        return {
+          path: repository.path,
+          status: 'failed',
+          branch,
+          reason: tree.stderr.trim() || 'unable to record generated upgrade tree',
+        }
+      const commit = spawnSync(
+        'git',
+        [
+          '-C',
+          temporary,
+          '-c',
+          'core.hooksPath=.githooks',
+          'commit',
+          '-m',
+          `chore(code-foundry): upgrade runtime to ${version}`,
+          '-m',
+          `${commitMarker}\nCode-Foundry-Tree: ${tree.stdout.trim()}`,
+        ],
+        { encoding: 'utf8' }
+      )
+      if (commit.status !== 0)
+        return {
+          path: repository.path,
+          status: 'failed',
+          branch,
+          reason: commit.stderr.trim() || 'commit failed',
+        }
+      const committedTree = spawnSync('git', ['-C', temporary, 'rev-parse', 'HEAD^{tree}'], {
+        encoding: 'utf8',
+      })
+      if (committedTree.status !== 0 || committedTree.stdout.trim() !== tree.stdout.trim())
+        return {
+          path: repository.path,
+          status: 'failed',
+          branch,
+          reason: 'Commit hook changed the generated upgrade tree',
+        }
+      const sha = spawnSync('git', ['-C', temporary, 'rev-parse', 'HEAD'], { encoding: 'utf8' })
+      if (sha.status !== 0)
+        return {
+          path: repository.path,
+          status: 'failed',
+          branch,
+          reason: 'unable to inspect generated upgrade commit',
+        }
+      const update = spawnSync(
+        'git',
+        [
+          '-C',
+          repository.path,
+          'update-ref',
+          `refs/heads/${branch}`,
+          sha.stdout.trim(),
+          '0'.repeat(40),
+        ],
+        { encoding: 'utf8' }
+      )
+      if (update.status !== 0)
+        return {
+          path: repository.path,
+          status: 'failed',
+          branch,
+          reason: update.stderr.trim() || 'unable to retain generated upgrade commit',
+        }
+      validatedHead = sha.stdout.trim()
     }
-    if (!result.changed.length) return { path: repository.path, status: 'unchanged', branch }
-    spawnSync('git', ['-C', temporary, 'add', '-A'], { stdio: 'ignore' })
-    const commit = spawnSync(
-      'git',
-      ['-C', temporary, 'commit', '-m', `chore(code-foundry): upgrade runtime to ${version}`],
+    if (remote && remote !== validatedHead)
+      return {
+        path: repository.path,
+        status: 'failed',
+        branch,
+        reason: 'Upgrade branch changed during validation; refusing to create a pull request',
+      }
+    if (!remote) {
+      const push = spawnSync(
+        'git',
+        ['-C', temporary, 'push', '-u', 'origin', `HEAD:refs/heads/${branch}`],
+        { encoding: 'utf8' }
+      )
+      if (push.status !== 0)
+        return {
+          path: repository.path,
+          status: 'failed',
+          branch,
+          reason: push.stderr.trim() || 'push failed',
+        }
+      const pushed = spawnSync(
+        'git',
+        ['-C', repository.path, 'ls-remote', '--heads', 'origin', `refs/heads/${branch}`],
+        { encoding: 'utf8' }
+      )
+      if (pushed.status !== 0 || pushed.stdout.trim().split(/\s/)[0] !== validatedHead)
+        return {
+          path: repository.path,
+          status: 'failed',
+          branch,
+          reason: 'Upgrade branch did not retain the validated commit',
+        }
+    }
+    const listed = spawnSync(
+      'gh',
+      [
+        'pr',
+        'list',
+        '--repo',
+        repository.repository,
+        '--head',
+        branch,
+        '--base',
+        base,
+        '--state',
+        'all',
+        '--limit',
+        '100',
+        '--json',
+        'url,body,state,headRefName,headRefOid,baseRefName,isCrossRepository,isDraft',
+      ],
       { encoding: 'utf8' }
     )
-    if (commit.status !== 0)
+    if (listed.status !== 0)
+      return {
+        path: repository.path,
+        status: 'failed',
+        branch,
+        reason: listed.stderr.trim() || 'unable to inspect upgrade pull requests',
+      }
+    let pullRequests
+    try {
+      pullRequests = JSON.parse(listed.stdout)
+    } catch {
       return {
         path: repository.path,
         status: 'failed',
-        reason: commit.stderr.trim() || 'commit failed',
+        branch,
+        reason: 'invalid pull request list',
       }
-    const push = spawnSync('git', ['-C', temporary, 'push', '-u', 'origin', branch], {
-      encoding: 'utf8',
-    })
-    if (push.status !== 0)
+    }
+    if (!Array.isArray(pullRequests) || pullRequests.length > 1)
       return {
         path: repository.path,
         status: 'failed',
-        reason: push.stderr.trim() || 'push failed',
+        branch,
+        reason: 'Ambiguous upgrade pull requests',
       }
+    const existingPr = pullRequests[0]
+    if (existingPr) {
+      if (
+        !existingPr.body?.includes(marker) ||
+        existingPr.headRefName !== branch ||
+        existingPr.baseRefName !== base ||
+        existingPr.headRefOid !== validatedHead ||
+        existingPr.isCrossRepository !== false
+      )
+        return {
+          path: repository.path,
+          status: 'failed',
+          branch,
+          reason: 'Existing pull request does not match this rollout policy',
+        }
+      return {
+        path: repository.path,
+        status: 'pr-existing',
+        branch,
+        pullRequest: existingPr.url,
+        draft: existingPr.isDraft,
+      }
+    }
     const pr = spawnSync(
       'gh',
       [
         'pr',
         'create',
+        '--draft',
         '--repo',
         repository.repository,
         '--base',
@@ -182,22 +439,78 @@ function upgradeRepository(repository, source, version) {
         '--title',
         `chore(code-foundry): upgrade to ${version}`,
         '--body',
-        `Automated isolated Code Foundry runtime upgrade to ${version}.\n\nThe sync preserved protected repository-owned documents and custom workflows.`,
+        `${marker}\n\nAutomated isolated Code Foundry runtime upgrade to ${version}.\n\nThe sync preserved protected repository-owned documents and custom workflows.`,
       ],
       { encoding: 'utf8' }
     )
-    return pr.status === 0
-      ? { path: repository.path, status: 'pr-created', branch, pullRequest: pr.stdout.trim() }
-      : {
-          path: repository.path,
-          status: 'failed',
-          branch,
-          reason: pr.stderr.trim() || 'pull request creation failed',
-        }
+    if (pr.status !== 0)
+      return {
+        path: repository.path,
+        status: 'failed',
+        branch,
+        reason: pr.stderr.trim() || 'pull request creation failed',
+      }
+    const created = spawnSync(
+      'gh',
+      [
+        'pr',
+        'view',
+        pr.stdout.trim(),
+        '--repo',
+        repository.repository,
+        '--json',
+        'headRefOid,headRefName,baseRefName,isCrossRepository,isDraft',
+      ],
+      { encoding: 'utf8' }
+    )
+    if (created.status !== 0)
+      return {
+        path: repository.path,
+        status: 'failed',
+        branch,
+        reason: created.stderr.trim() || 'unable to verify created pull request',
+      }
+    let createdPr
+    try {
+      createdPr = JSON.parse(created.stdout)
+    } catch {
+      return {
+        path: repository.path,
+        status: 'failed',
+        branch,
+        reason: 'invalid created pull request',
+      }
+    }
+    if (
+      createdPr.headRefOid !== validatedHead ||
+      createdPr.headRefName !== branch ||
+      createdPr.baseRefName !== base ||
+      createdPr.isCrossRepository !== false ||
+      createdPr.isDraft !== true
+    )
+      return {
+        path: repository.path,
+        status: 'failed',
+        branch,
+        reason: 'Created pull request does not reference the validated draft rollout branch',
+      }
+    return {
+      path: repository.path,
+      status: existing ? 'pr-resumed' : 'pr-created',
+      branch,
+      pullRequest: pr.stdout.trim(),
+    }
   } finally {
-    spawnSync('git', ['-C', repository.path, 'worktree', 'remove', '--force', temporary], {
-      stdio: 'ignore',
-    })
+    if (attached) {
+      const cleanup = spawnSync(
+        'git',
+        ['-C', repository.path, 'worktree', 'remove', '--force', temporary],
+        { encoding: 'utf8' }
+      )
+      if (cleanup.status !== 0)
+        console.error(`Preserved isolated worktree after cleanup failure: ${temporary}`)
+      else rmSync(temporary, { recursive: true, force: true })
+    } else rmSync(temporary, { recursive: true, force: true })
   }
 }
 

package/src/commands/sync.mjs

@@ -105,7 +105,7 @@ const legacyFiles = [
   '.github/licenses/AGPL-3.0-or-later.txt',
 ]
 
-/** @typedef {{ target: string, source: string, dryRun?: boolean, force?: boolean, init?: boolean, runtimeRef?: string }} SyncOptions */
+/** @typedef {{ target: string, source: string, dryRun?: boolean, force?: boolean, init?: boolean, runtimeRef?: string, configureHooks?: boolean }} SyncOptions */
 
 /** @param {SyncOptions} options */
 export function syncRepository(options) {
@@ -115,6 +115,7 @@ export function syncRepository(options) {
   const force = options.force ?? false
   const configPath = join(target, '.github/code-foundry.yml')
   const existingConfig = readConfig(configPath)
+  const changed = []
   if (!Object.keys(existingConfig).length && !options.init)
     throw new Error('Missing .github/code-foundry.yml; run init first.')
   const defaults = createDefaultConfig(target, source, existingConfig.git_workflow)
@@ -141,12 +142,14 @@ export function syncRepository(options) {
     throw new Error(`Unsupported license: ${license}; use ${supported}.`)
   }
   if (!Object.keys(existingConfig).length) {
+    changed.push('.github/code-foundry.yml')
     writeOrReport(configPath, renderConfig(config), dryRun)
   } else {
     const missing = Object.keys(defaults).filter((key) => !(key in existingConfig))
     const original = readFileSync(configPath, 'utf8')
     const normalized = removeConfigKeys(original, obsoleteConfigKeys).trimEnd()
     if (missing.length || normalized !== original.trimEnd()) {
+      changed.push('.github/code-foundry.yml')
       const additions = missing.map((key) => renderConfigLine(key, defaults[key])).join('\n')
       writeOrReport(configPath, `${normalized}${additions ? `\n${additions}` : ''}\n`, dryRun)
     }
@@ -197,8 +200,6 @@ export function syncRepository(options) {
       )
     }
   }
-  const changed = []
-
   // Keep normal semver pins current during sync while preserving intentional
   // refs such as `main`, `staging`, or a custom immutable SHA. An explicit
   // runtime ref (fleet upgrade) is authoritative and overrides even those so
@@ -415,7 +416,11 @@ export function syncRepository(options) {
       }
     }
   }
-  if (!dryRun && existsSync(join(target, '.githooks/pre-commit'))) {
+  if (
+    !dryRun &&
+    options.configureHooks !== false &&
+    existsSync(join(target, '.githooks/pre-commit'))
+  ) {
     chmodSync(join(target, '.githooks/pre-commit'), 0o755)
     git(target, ['config', 'core.hooksPath', '.githooks'])
   }
@@ -809,8 +814,8 @@ const DIRECT_DOC_REPLACEMENTS = {
       '| Change                    | Target | Merge method                      | Merge gate                              |\n| ------------------------- | ------ | --------------------------------- | --------------------------------------- |\n| Working branch            | `main` | Squash                            | All applicable required checks pass     |\n| Release Please version PR | `main` | Squash (`release_merge_strategy`) | Validation gate and release policy pass |\n',
     ],
     [
-      'Draft pull requests do not start runner-heavy validation. The lightweight Draft Guard also converts ordinary pull requests opened, reopened, or updated while ready back to draft; it never checks out pull-request code and it excludes Release Please version heads, whose release workflow owns their state. Marking a pull request ready for review starts the applicable validation tier. Convert it back to draft after an update, then mark it ready again after every update so the required checks attach to the current head; converting it back to draft cancels in-flight validation, and no replacement starts until it is ready again.',
-      'Draft pull requests do not start validation. The lightweight Draft Guard also converts ordinary pull requests opened, reopened, or updated while ready back to draft; it never checks out pull-request code and it excludes Release Please version heads, whose release workflow owns their state. Marking a pull request ready for review starts the applicable validation tier. Convert it back to draft after an update, then mark it ready again after every update so the required checks attach to the current head. Converting it to draft runs only the lightweight cancellation control.',
+      'Draft pull requests do not start runner-heavy validation. The lightweight Draft Guard converts ordinary pull requests opened or reopened while ready back to draft; it never checks out pull-request code and it excludes Release Please version heads, whose release workflow owns their state. Marking a pull request ready for review starts the applicable validation tier, and each new commit on a ready pull request reruns that tier for the current head. Draft updates allocate no validation runner. Converting a pull request to draft cancels in-flight validation through the lightweight cancellation control.',
+      'Draft pull requests do not start validation. The lightweight Draft Guard converts ordinary pull requests opened or reopened while ready back to draft; it never checks out pull-request code and it excludes Release Please version heads, whose release workflow owns their state. Marking a pull request ready for review starts the applicable validation tier, and each new commit on a ready pull request reruns that tier for the current head. Draft updates allocate no validation runner. Converting a pull request to draft runs only the lightweight cancellation control.',
     ],
     ['1. Create a focused branch from `staging`.', '1. Create a focused branch from `main`.'],
   ],