@1aboveio/skills 1.0.10 → 1.0.12

package/skills/app-dev/android-foundation/scripts/workspace-runtime/native-workspace.mjs

@@ -0,0 +1,239 @@
+import { execFileSync, spawnSync } from 'node:child_process'
+import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmdirSync, unlinkSync, writeFileSync } from 'node:fs'
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path'
+import { randomUUID } from 'node:crypto'
+import { fileURLToPath } from 'node:url'
+
+const cli = fileURLToPath(new URL('./bin/workspaces.mjs', import.meta.url))
+const git = (cwd, ...args) => execFileSync('git', ['-C', cwd, ...args], { encoding: 'utf8', timeout: 30_000, stdio: ['ignore', 'pipe', 'pipe'] }).trim()
+const component = (value) => typeof value === 'string' && /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(value) && value !== '.' && value !== '..'
+
+function stat(path) {
+  try { return lstatSync(path) } catch (error) { if (error.code === 'ENOENT') return null; throw error }
+}
+
+function noLinks(root, path) {
+  const rel = relative(root, path)
+  if (rel.startsWith(`..${sep}`) || rel === '..' || isAbsolute(rel)) throw new Error('workspace path escapes its repository')
+  let current = root
+  for (const part of rel.split(sep).filter(Boolean)) {
+    current = join(current, part)
+    if (stat(current)?.isSymbolicLink()) throw new Error(`symlink in managed path: ${current}`)
+  }
+}
+
+// This lock owns the plan, including initial creation. The engine independently locks
+// workspace operations; its shorter lock cannot protect our read/modify/write cycle.
+function withOwner(repo, run, operation) {
+  const locks = join(dirname(run), '.native-locks')
+  const lock = join(locks, basename(run))
+  noLinks(repo, run)
+  noLinks(repo, lock)
+  mkdirSync(locks, { recursive: true })
+  try { mkdirSync(lock) } catch (error) {
+    if (error.code !== 'EEXIST') throw error
+    let owner = 'unknown owner'
+    try { owner = `owner PID ${JSON.parse(readFileSync(join(lock, 'owner.json'), 'utf8')).pid ?? 'unknown'}` } catch { /* Unknown owners also block. */ }
+    throw new Error(`native run is locked at ${lock} (${owner}); locks are never reclaimed by age`)
+  }
+  try {
+    writeFileSync(join(lock, 'owner.json'), `${JSON.stringify({ pid: process.pid, run, at: new Date().toISOString() })}\n`, { flag: 'wx', mode: 0o600 })
+    return operation()
+  } finally {
+    try { unlinkSync(join(lock, 'owner.json')) } catch (error) {
+      if (error.code !== 'ENOENT') throw error
+    } finally {
+      rmdirSync(lock)
+      try { rmdirSync(locks) } catch (error) { if (!['ENOTEMPTY', 'ENOENT', 'EEXIST'].includes(error.code)) throw error }
+    }
+  }
+}
+
+function planStore(repo, run) {
+  const file = join(run, 'task-plan.json')
+  const read = () => {
+    noLinks(repo, file)
+    return stat(file) ? readFileSync(file, 'utf8') : null
+  }
+  let expected = read()
+  const plan = expected === null ? null : JSON.parse(expected)
+  let revision = plan?.planRevision ?? -1
+  return {
+    plan,
+    save(next) {
+      if (read() !== expected || (expected !== null && JSON.parse(expected).planRevision !== revision)) {
+        throw new Error('native plan revision/content changed; refusing to overwrite another owner')
+      }
+      next.planRevision = revision + 1
+      const text = `${JSON.stringify(next, null, 2)}\n`
+      const temp = `${file}.${randomUUID()}.tmp`
+      try {
+        writeFileSync(temp, text, { flag: 'wx', mode: 0o600 })
+        if (read() !== expected) throw new Error('native plan changed before persist; refusing to overwrite another owner')
+        renameSync(temp, file)
+        expected = text
+        revision = next.planRevision
+      } finally {
+        if (stat(temp)) unlinkSync(temp)
+      }
+    },
+  }
+}
+
+function ownedPlan(plan, repo, run) {
+  const unit = plan?.units?.[0]
+  if (plan?.skill !== 'native-setup' || plan.workspaceLifecycle !== 1 || plan.repoRoot !== repo || plan.runDir !== run ||
+      !Number.isSafeInteger(plan.planRevision) || plan.planRevision < 0 || plan.units?.length !== 1 || unit?.id !== 'native' ||
+      unit.workspace !== join(run, 'units', 'native') || unit.lifecycle?.version !== 1 ||
+      !['worktree', 'clone'].includes(unit.lifecycle.workspace?.kind) || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(unit.lifecycle.workspace?.baseSha ?? '') ||
+      unit.base !== unit.lifecycle.workspace.baseSha || !Array.isArray(unit.lifecycle.resources)) {
+    throw new Error('not an owned standalone native run; refusing to replace its record')
+  }
+  git(repo, 'check-ref-format', '--branch', plan.targetBranch)
+  git(repo, 'check-ref-format', '--branch', unit.branch)
+  noLinks(repo, unit.workspace)
+  return unit
+}
+
+function relativePath(value, label, allowRoot = false) {
+  if (allowRoot && value === '.') return value
+  if (typeof value !== 'string' || !value || isAbsolute(value) || value.includes('\\') || /[\0*?\[\]]/.test(value) ||
+      value.split('/').some((part) => !part || part === '.' || part === '..' || part === '.git' || part === '.resolve-issues')) {
+    throw new Error(`${label} must be an exact relative path without .., symlinks, or managed roots`)
+  }
+  return value
+}
+
+function resourcePaths(repo, workspace, platform, nativeDir, disposable) {
+  relativePath(nativeDir, '--native-dir', true)
+  if (!Array.isArray(disposable)) throw new Error('disposable must be an array of workspace-relative paths')
+  const paths = [...new Set(['.cache', 'node_modules',
+    ...(platform === 'ios' ? ['ios/Pods'] : ['android/.gradle', 'android/build', 'android/app/build']).map((path) => nativeDir === '.' ? path : `${nativeDir}/${path}`),
+    ...disposable.map((path) => relativePath(path, '--disposable'))])]
+  noLinks(repo, join(repo, nativeDir))
+  noLinks(repo, join(workspace, nativeDir))
+  for (const path of paths) {
+    noLinks(repo, join(repo, path))
+    noLinks(repo, join(workspace, path))
+  }
+  return paths
+}
+
+function engine(args, repo) {
+  const result = spawnSync(process.execPath, [cli, ...args, '--json'], { cwd: repo, encoding: 'utf8', timeout: 120_000, maxBuffer: 8 * 1024 * 1024 })
+  let value
+  try { value = JSON.parse(result.stdout) } catch { /* Report the failed command below. */ }
+  if (result.status === 0 || (result.status === 1 && value?.action === 'retain' && (value.lifecycle || value.nextLifecycle))) return value
+  throw new Error(result.stderr?.trim() || result.stdout?.trim() || result.error?.message || 'workspace operation failed')
+}
+
+function returnedLifecycle(result) {
+  const lifecycle = result?.lifecycle ?? result?.nextLifecycle
+  if (!lifecycle || lifecycle.version !== 1) throw new Error('workspace helper returned no lifecycle transition; the recorded intent remains recoverable')
+  return lifecycle
+}
+
+export function nativeStart({ repo: input, runId, base, branch, target, platform, kind, nativeDir, disposable = [] }) {
+  if (!input || !['android', 'ios'].includes(platform) || (kind !== undefined && !['worktree', 'clone'].includes(kind))) throw new Error('native-start requires --repo and --platform android|ios; --kind is worktree or clone')
+  const repo = realpathSync(resolve(input))
+  if (realpathSync(git(repo, 'rev-parse', '--show-toplevel')) !== repo) throw new Error('--repo must name the owning checkout root')
+  const id = runId ?? `native-${new Date().toISOString().replace(/[^0-9]/g, '')}-${process.pid}`
+  if (!component(id)) throw new Error('invalid native run id')
+  const run = join(repo, '.resolve-issues', 'rush', id)
+  return withOwner(repo, run, () => {
+    const store = planStore(repo, run)
+    let plan = store.plan
+    if (!plan && stat(run)) throw new Error('existing run has no ownership record; refusing to adopt it')
+    let unit
+    if (plan) {
+      unit = ownedPlan(plan, repo, run)
+      if ((base !== undefined && git(repo, 'rev-parse', '--verify', `${base}^{commit}`) !== unit.base) ||
+          (target !== undefined && target !== plan.targetBranch) || (kind !== undefined && kind !== unit.lifecycle.workspace.kind) ||
+          (branch !== undefined && branch !== unit.branch) || (nativeDir !== undefined && nativeDir !== (unit.nativeDir ?? '.'))) {
+        throw new Error('existing native run belongs to a different setup; refusing to replace it')
+      }
+      nativeDir = unit.nativeDir ?? '.'
+    } else {
+      const baseSha = git(repo, 'rev-parse', '--verify', `${base ?? 'HEAD'}^{commit}`)
+      if (!target) {
+        try { target = git(repo, 'symbolic-ref', '--short', 'refs/remotes/origin/HEAD').replace(/^origin\//, '') } catch { throw new Error('record the repository target branch with --target; origin/HEAD is unavailable') }
+      }
+      branch ??= `native/${id}`
+      kind ??= 'worktree'
+      nativeDir ??= '.'
+      git(repo, 'check-ref-format', '--branch', target)
+      git(repo, 'check-ref-format', '--branch', branch)
+      unit = { id: 'native', title: 'Standalone native setup', workspace: join(run, 'units', 'native'), branch, base: baseSha, nativeDir, disposable: [], status: 'in-flight', stage: 'implement', worker: null,
+        lifecycle: { version: 1, workspace: { kind, state: 'preparing', baseSha }, resources: [], cleanup: { state: 'pending' } } }
+      plan = { skill: 'native-setup', workspaceLifecycle: 1, repoRoot: repo, runDir: run, targetBranch: target, planRevision: 0, units: [unit] }
+    }
+    if (unit.lifecycle.cleanup?.state === 'complete') throw new Error('this setup was cleaned; start a new run rather than recreating a used workspace')
+    if (!Array.isArray(disposable) || (unit.disposable !== undefined && !Array.isArray(unit.disposable))) throw new Error('disposable must be an array of workspace-relative paths')
+    const extras = [...new Set([...(unit.disposable ?? []), ...disposable])]
+    const paths = resourcePaths(repo, unit.workspace, platform, nativeDir, extras)
+    let changed = !store.plan || unit.nativeDir === undefined || JSON.stringify(unit.disposable) !== JSON.stringify(extras)
+    unit.nativeDir = nativeDir
+    unit.disposable = extras
+    for (const item of paths) {
+      const path = join(unit.workspace, item)
+      if (unit.lifecycle.resources.some((r) => r.path === path)) continue
+      unit.lifecycle.resources.push({ path, role: 'scratch', kind: 'directory', disposable: true, state: 'preparing' })
+      changed = true
+    }
+    if (!store.plan) mkdirSync(run)
+    if (changed) store.save(plan)
+    const result = engine(['prepare', '--run', run, '--unit', 'native', '--revision', String(plan.planRevision), '--apply'], repo)
+    unit.lifecycle = returnedLifecycle(result)
+    store.save(plan)
+    return { ...result, run, runId: id, workspace: unit.workspace, nativeDir, disposable: extras, sourceSha: git(unit.workspace, 'rev-parse', 'HEAD'), planRevision: plan.planRevision }
+  })
+}
+
+export function nativeFinish({ run: input }) {
+  if (!input) throw new Error('native-finish requires --run')
+  const run = resolve(input)
+  const repo = realpathSync(join(run, '..', '..', '..'))
+  if (!component(basename(run)) || run !== join(repo, '.resolve-issues', 'rush', basename(run))) throw new Error('not an owned standalone native run')
+  noLinks(repo, run)
+  if (!stat(run)?.isDirectory()) throw new Error('native run does not exist')
+  return withOwner(repo, run, () => {
+    const store = planStore(repo, run)
+    const plan = store.plan
+    const unit = ownedPlan(plan, repo, run)
+    // Completed and interrupted removals still go through the engine's postcondition
+    // checks, including owned resources outside the workspace and cleanup receipts.
+    const completeCleanup = () => {
+      const result = engine(['cleanup', '--run', run, '--unit', 'native', '--revision', String(plan.planRevision), '--apply'], repo)
+      const lifecycle = returnedLifecycle(result)
+      if (result.ok !== false && (lifecycle.cleanup?.state !== 'complete' || existsSync(unit.workspace) || lifecycle.resources.some((r) => existsSync(r.path)))) {
+        throw new Error('cleanup has not reached its postconditions; the recorded intent remains recoverable')
+      }
+      unit.lifecycle = lifecycle
+      store.save(plan)
+      return { ...result, run, planRevision: plan.planRevision }
+    }
+    if (unit.lifecycle.cleanup?.state === 'complete' || (!existsSync(unit.workspace) && unit.lifecycle.cleanup?.state === 'applying')) return completeCleanup()
+    const headSha = git(unit.workspace, 'rev-parse', 'HEAD')
+    const remote = git(repo, 'remote', 'get-url', 'origin')
+    git(unit.workspace, 'fetch', '--no-tags', '--', remote, `+refs/heads/${plan.targetBranch}:refs/remotes/native-delivery/${plan.targetBranch}`)
+    const targetRef = `refs/remotes/native-delivery/${plan.targetBranch}`
+    let landed = false
+    try { git(unit.workspace, 'merge-base', '--is-ancestor', headSha, targetRef); landed = true } catch (error) {
+      if (error.status !== 1) throw error
+    }
+    if (!landed) {
+      unit.headSha = headSha
+      const reason = 'native source has not landed on the recorded remote target; retain its environment'
+      unit.lifecycle.cleanup = { state: 'retained', headSha, reason }
+      store.save(plan)
+      return { ok: false, action: 'retain', outcome: 'retained', reason, run, lifecycle: unit.lifecycle, planRevision: plan.planRevision }
+    }
+    unit.headSha = headSha
+    unit.mergeSha = headSha
+    unit.status = 'succeeded'
+    unit.delivery = 'merged'
+    unit.lifecycle.cleanup = { state: 'applying', headSha }
+    store.save(plan)
+    return completeCleanup()
+  })
+}