@happier-dev/stack 0.2.1-preview.1775586714.26562 → 0.2.11

package/scripts/utils/expo/command_workspace_deps_built.test.mjs

@@ -2,8 +2,10 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { chmod, mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { delimiter, join } from 'node:path';
 
+import { withPatchedProcessEnv } from '../../testkit/core/env_scope.mjs';
+import { writeWorkspacePackageBuildOwnerProxy } from '../../testkit/core/workspace_package_build_owner.mjs';
 import { expoExec } from './command.mjs';
 
 async function writeJson(path, value) {
@@ -21,6 +23,7 @@ async function writeYarnStub({ binDir, outputPath }) {
       'echo "$(pwd) :: $*" >> "${OUTPUT_PATH:?}"',
       '',
       'if [[ "${1:-}" == "--version" ]]; then',
+      '  IFS= read -r _ || true',
       '  echo "1.22.22"',
       '  exit 0',
       'fi',
@@ -30,11 +33,12 @@ async function writeYarnStub({ binDir, outputPath }) {
       'fi',
       '',
       'if [[ "${1:-}" == "-s" && "${2:-}" == "build" && "$(pwd)" == */packages/protocol ]]; then',
-      '  mkdir -p dist',
-      "  printf '%s\\n' 'export const ok = true;' > dist/index.js",
-      "  printf '%s\\n' 'export const ok = true;' > dist/rpcErrors.js",
-      "  printf '%s\\n' 'export declare const ok: boolean;' > dist/index.d.ts",
-      "  printf '%s\\n' 'export declare const ok: boolean;' > dist/rpcErrors.d.ts",
+      '  out="${HAPPIER_WORKSPACE_DIST_OUTPUT_DIR:-dist}"',
+      '  mkdir -p "$out"',
+      "  printf '%s\\n' 'export const ok = true;' > \"$out/index.js\"",
+      "  printf '%s\\n' 'export const ok = true;' > \"$out/rpcErrors.js\"",
+      "  printf '%s\\n' 'export declare const ok: boolean;' > \"$out/index.d.ts\"",
+      "  printf '%s\\n' 'export declare const ok: boolean;' > \"$out/rpcErrors.d.ts\"",
       '  exit 0',
       'fi',
       '',
@@ -43,6 +47,34 @@ async function writeYarnStub({ binDir, outputPath }) {
     'utf-8',
   );
   await chmod(yarnPath, 0o755);
+  await writeFile(
+    join(binDir, 'yarn.cmd'),
+    [
+      '@echo off',
+      'setlocal EnableExtensions EnableDelayedExpansion',
+      'echo %CD% :: %*>>"%OUTPUT_PATH%"',
+      'if "%~1"=="--version" (',
+      '  set /p "_="',
+      '  echo 1.22.22',
+      '  exit /b 0',
+      ')',
+      'if "%~1"=="install" exit /b 0',
+      'if "%~1"=="-s" if "%~2"=="build" (',
+      '  if /I "%CD%"=="' + join(binDir, '..', 'packages', 'protocol') + '" (',
+      '    set "out=%HAPPIER_WORKSPACE_DIST_OUTPUT_DIR%"',
+      '    if not defined out set "out=dist"',
+      '    if not exist "!out!" mkdir "!out!"',
+      "    >\"!out!\\index.js\" echo export const ok = true;",
+      "    >\"!out!\\rpcErrors.js\" echo export const ok = true;",
+      "    >\"!out!\\index.d.ts\" echo export declare const ok: boolean;",
+      "    >\"!out!\\rpcErrors.d.ts\" echo export declare const ok: boolean;",
+      '  )',
+      '  exit /b 0',
+      ')',
+      'exit /b 0',
+    ].join('\r\n') + '\r\n',
+    'utf-8',
+  );
   await writeFile(outputPath, '', 'utf-8');
 }
 
@@ -64,6 +96,18 @@ async function writeExpoStub({ expoPath }) {
     'utf-8',
   );
   await chmod(expoPath, 0o755);
+  await writeFile(
+    `${expoPath}.cmd`,
+    [
+      '@echo off',
+      'if not exist "..\\..\\packages\\protocol\\dist\\rpcErrors.js" (',
+      '  echo missing ..\\..\\packages\\protocol\\dist\\rpcErrors.js 1>&2',
+      '  exit /b 3',
+      ')',
+      'exit /b 0',
+    ].join('\r\n') + '\r\n',
+    'utf-8',
+  );
 }
 
 async function writeExpoStubCaptureCwd({ expoPath }) {
@@ -86,29 +130,25 @@ async function writeExpoStubCaptureCwd({ expoPath }) {
     'utf-8',
   );
   await chmod(expoPath, 0o755);
+  await writeFile(
+    `${expoPath}.cmd`,
+    [
+      '@echo off',
+      'echo expo:cwd=%CD% bin=%~f0 args=%*>>"%OUTPUT_PATH%"',
+      'if not exist "..\\..\\packages\\protocol\\dist\\rpcErrors.js" (',
+      '  echo missing ..\\..\\packages\\protocol\\dist\\rpcErrors.js 1>&2',
+      '  exit /b 3',
+      ')',
+      'exit /b 0',
+    ].join('\r\n') + '\r\n',
+    'utf-8',
+  );
 }
 
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
-function applyEnvOverrides(t, vars) {
-  const previous = {};
-  for (const key of Object.keys(vars)) {
-    previous[key] = process.env[key];
-  }
-  t.after(() => {
-    for (const [key, value] of Object.entries(previous)) {
-      if (value == null) delete process.env[key];
-      else process.env[key] = value;
-    }
-  });
-  for (const [key, value] of Object.entries(vars)) {
-    if (value == null) delete process.env[key];
-    else process.env[key] = String(value);
-  }
-}
-
 test('expoExec builds workspace dist deps for the projectDir (not the runnerDir)', async (t) => {
   const root = await mkdtemp(join(tmpdir(), 'hs-expo-workspace-deps-built-'));
   t.after(async () => {
@@ -121,6 +161,7 @@ test('expoExec builds workspace dist deps for the projectDir (not the runnerDir)
   await mkdir(join(root, 'apps', 'server'), { recursive: true });
   await writeJson(join(root, 'package.json'), { name: 'repo', private: true });
   await writeFile(join(root, 'yarn.lock'), '# lock\n', 'utf-8');
+  await writeWorkspacePackageBuildOwnerProxy(root);
 
   // Root does NOT depend on protocol; only apps/ui does.
   await writeJson(join(root, 'apps', 'ui', 'package.json'), {
@@ -152,12 +193,16 @@ test('expoExec builds workspace dist deps for the projectDir (not the runnerDir)
   const binDir = join(root, 'bin');
   const outputPath = join(root, 'argv.txt');
   await writeYarnStub({ binDir, outputPath });
+  const yarnCmd = await readFile(join(binDir, 'yarn.cmd'), 'utf-8');
+  assert.match(yarnCmd, /setlocal EnableExtensions EnableDelayedExpansion/);
+  assert.doesNotMatch(yarnCmd, /%out%/);
+  assert.equal((yarnCmd.match(/!out!\\(?:index|rpcErrors)(?:\.d\.ts|\.js)/g) ?? []).length, 4);
 
   const expoPath = join(root, 'node_modules', '.bin', 'expo');
   await writeExpoStub({ expoPath });
 
-  applyEnvOverrides(t, {
-    PATH: `${binDir}:/usr/bin:/bin`,
+  withPatchedProcessEnv(t, {
+    PATH: `${binDir}${delimiter}${process.env.PATH ?? ''}`,
     OUTPUT_PATH: outputPath,
     HAPPIER_STACK_ENV_FILE: null,
   });
@@ -191,6 +236,7 @@ test('expoExec falls back to the monorepo root expo bin when runnerDir lacks nod
   await mkdir(join(root, 'apps', 'server'), { recursive: true });
   await writeJson(join(root, 'package.json'), { name: 'repo', private: true });
   await writeFile(join(root, 'yarn.lock'), '# lock\n', 'utf-8');
+  await writeWorkspacePackageBuildOwnerProxy(root);
 
   await writeJson(join(root, 'apps', 'ui', 'package.json'), {
     name: '@happier-dev/app',
@@ -226,8 +272,8 @@ test('expoExec falls back to the monorepo root expo bin when runnerDir lacks nod
   const expoPath = join(root, 'node_modules', '.bin', 'expo');
   await writeExpoStubCaptureCwd({ expoPath });
 
-  applyEnvOverrides(t, {
-    PATH: `${binDir}:/usr/bin:/bin`,
+  withPatchedProcessEnv(t, {
+    PATH: `${binDir}${delimiter}${process.env.PATH ?? ''}`,
     OUTPUT_PATH: outputPath,
     HAPPIER_STACK_ENV_FILE: null,
   });
@@ -245,6 +291,6 @@ test('expoExec falls back to the monorepo root expo bin when runnerDir lacks nod
   assert.match(argvLog, /expo:cwd=/);
   // macOS can report tmp paths via `/private/var/...` even if `mkdtemp()` returns `/var/...`.
   // Only assert stable suffixes.
-  assert.match(argvLog, /expo:cwd=.*\/apps\/ui\b/);
-  assert.match(argvLog, /bin=.*\/node_modules\/\.bin\/expo\b/);
+  assert.match(argvLog, /expo:cwd=.*[\\/]apps[\\/]ui\b/);
+  assert.match(argvLog, /bin=.*[\\/]node_modules[\\/]\.bin[\\/]expo(?:\.cmd)?\b/);
 });

package/scripts/utils/expo/expo.mjs

@@ -1,11 +1,13 @@
 import { createHash } from 'node:crypto';
 import { existsSync } from 'node:fs';
-import { mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, readdir, unlink } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
 import { isPidAlive } from '../proc/pids.mjs';
-import { isTcpPortFree, listListenPids } from '../net/ports.mjs';
+import { isTcpPortFree, listListenPidsWithStatus } from '../net/ports.mjs';
 import { runCapture } from '../proc/proc.mjs';
+import { writeJsonAtomic } from '../fs/json.mjs';
+import { withJsonOwnerFileLock } from '../proc/jsonOwnerFileLock.mjs';
 
 export { isPidAlive };
 
@@ -16,10 +18,10 @@ function resolveMetroStatusTimeoutMsFromEnv(env = process.env) {
   return 800;
 }
 
-export async function looksLikeExpoMetro({ port, timeoutMs = null } = {}) {
+export async function looksLikeExpoMetro({ port, timeoutMs = null, env = process.env } = {}) {
   const p = Number(port);
   if (!Number.isFinite(p) || p <= 0) return false;
-  const ms = Number.isFinite(Number(timeoutMs)) && Number(timeoutMs) > 0 ? Number(timeoutMs) : resolveMetroStatusTimeoutMsFromEnv();
+  const ms = Number.isFinite(Number(timeoutMs)) && Number(timeoutMs) > 0 ? Number(timeoutMs) : resolveMetroStatusTimeoutMsFromEnv(env);
   const url = `http://127.0.0.1:${p}/status`;
   try {
     const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
@@ -50,17 +52,120 @@ function resolveMetroWaitIntervalMsFromEnv(env = process.env) {
   return 500;
 }
 
+async function getProcessGroupIdForReadiness(pid) {
+  const n = Number(pid);
+  if (!Number.isFinite(n) || n <= 1 || process.platform === 'win32') return null;
+  try {
+    const out = await runCapture('ps', ['-o', 'pgid=', '-p', String(n)]);
+    const pgid = Number(String(out ?? '').trim());
+    return Number.isFinite(pgid) && pgid > 1 ? pgid : null;
+  } catch {
+    return null;
+  }
+}
+
+async function isWindowsDescendantProcess(listenerPid, ownerPid) {
+  if (process.platform !== 'win32') return false;
+  const script = [
+    `$target=${Number(listenerPid)};`,
+    `$owner=${Number(ownerPid)};`,
+    'while ($target -gt 1) {',
+    '  $p=Get-CimInstance Win32_Process -Filter "ProcessId=$target";',
+    '  if (-not $p) { break };',
+    '  $target=[int]$p.ParentProcessId;',
+    '  if ($target -eq $owner) { Write-Output owned; exit 0 }',
+    '};',
+    'exit 1',
+  ].join(' ');
+  try {
+    const out = await runCapture('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', script], { timeoutMs: 4000 });
+    return String(out ?? '').trim() === 'owned';
+  } catch {
+    return false;
+  }
+}
+
+async function observeMetroListenerOwnership(
+  { port, ownerPid, env },
+  {
+    listListenPidsWithStatusImpl = listListenPidsWithStatus,
+    getProcessGroupIdImpl = getProcessGroupIdForReadiness,
+    isWindowsDescendantProcessImpl = isWindowsDescendantProcess,
+    platform = process.platform,
+  } = {},
+) {
+  const listeners = await listListenPidsWithStatusImpl(port, { timeoutMs: 4000, env });
+  if (listeners.status !== 'ok') {
+    return { status: 'inconclusive', reason: listeners.reason ?? listeners.status, observation: listeners };
+  }
+  const listenerPids = listeners.pids;
+  if (!listenerPids.length) return { status: 'not_ready', reason: 'listener_not_observed', listenerPids };
+  const ownedListenerPids = [];
+  const foreignListenerPids = [];
+  if (platform === 'win32') {
+    for (const listenerPid of listenerPids) {
+      if (listenerPid === Number(ownerPid)) {
+        ownedListenerPids.push(listenerPid);
+        continue;
+      }
+      // eslint-disable-next-line no-await-in-loop
+      if (await isWindowsDescendantProcessImpl(listenerPid, ownerPid)) {
+        ownedListenerPids.push(listenerPid);
+      } else {
+        foreignListenerPids.push(listenerPid);
+      }
+    }
+  } else {
+    const ownerPgid = await getProcessGroupIdImpl(ownerPid);
+    for (const listenerPid of listenerPids) {
+      if (listenerPid === Number(ownerPid)) {
+        ownedListenerPids.push(listenerPid);
+        continue;
+      }
+      // eslint-disable-next-line no-await-in-loop
+      const listenerPgid = await getProcessGroupIdImpl(listenerPid);
+      if (ownerPgid && listenerPgid && listenerPgid === ownerPgid) {
+        ownedListenerPids.push(listenerPid);
+      } else {
+        foreignListenerPids.push(listenerPid);
+      }
+    }
+  }
+  if (foreignListenerPids.length) {
+    return {
+      status: 'not_owned',
+      reason: ownedListenerPids.length ? 'competing_listener' : 'listener_not_owned',
+      listenerPids,
+      ownedListenerPids,
+      foreignListenerPids,
+    };
+  }
+  if (!ownedListenerPids.length) {
+    return { status: 'not_owned', reason: 'listener_not_owned', listenerPids };
+  }
+  return { status: 'owned', reason: 'all_listeners_owned', listenerPids, ownedListenerPids };
+}
+
 export async function waitForExpoMetroRunning(
   {
     port,
+    ownerPid = null,
+    ownerProc = null,
     timeoutMs = null,
     intervalMs = null,
     env = process.env,
+    onTimeoutCheckpoint = ({ timeoutMs: checkpointMs }) => {
+      console.warn(`[stack] Metro is still starting on port ${port} after ${checkpointMs}ms; continuing to wait (TUI is attended)`);
+    },
   } = {},
   {
     looksLikeExpoMetroImpl = looksLikeExpoMetro,
     delayImpl = delay,
     nowMsImpl = () => Date.now(),
+    listListenPidsWithStatusImpl = listListenPidsWithStatus,
+    getProcessGroupIdImpl = getProcessGroupIdForReadiness,
+    isWindowsDescendantProcessImpl = isWindowsDescendantProcess,
+    platform = process.platform,
   } = {},
 ) {
   const p = Number(port);
@@ -76,19 +181,103 @@ export async function waitForExpoMetroRunning(
       ? Number(intervalMs)
       : resolveMetroWaitIntervalMsFromEnv(env);
 
-  const startMs = nowMsImpl();
+  let checkpointStartMs = nowMsImpl();
   let probes = 0;
-  while (nowMsImpl() - startMs <= resolvedTimeoutMs) {
+  let lastOwnership = null;
+  const ownershipRequired = typeof ownerPid === 'function' || (Number.isFinite(Number(ownerPid)) && Number(ownerPid) > 1);
+  while (true) {
+    if (ownerProc && (ownerProc.exitCode !== null || ownerProc.signalCode !== null)) {
+      return { ok: false, reason: 'owner_process_exited', probes };
+    }
+    if (nowMsImpl() - checkpointStartMs > resolvedTimeoutMs) {
+      const attendedOwnerAlive = env?.HAPPIER_STACK_TUI === '1'
+        && ownerProc
+        && ownerProc.exitCode == null
+        && ownerProc.signalCode == null;
+      if (!attendedOwnerAlive) break;
+      onTimeoutCheckpoint?.({ timeoutMs: resolvedTimeoutMs, port: p, probes });
+      checkpointStartMs = nowMsImpl();
+    }
+    // eslint-disable-next-line no-await-in-loop
+    const statusProbe = looksLikeExpoMetroImpl({ port: p, env });
     // eslint-disable-next-line no-await-in-loop
-    const ok = await looksLikeExpoMetroImpl({ port: p });
+    const statusResult = ownerProc
+      ? await new Promise((resolvePromise) => {
+          const onExit = () => resolvePromise({ kind: 'exit' });
+          ownerProc.once('exit', onExit);
+          statusProbe.then((ok) => {
+            ownerProc.removeListener('exit', onExit);
+            resolvePromise({ kind: 'status', ok });
+          });
+        })
+      : { kind: 'status', ok: await statusProbe };
+    if (statusResult.kind === 'exit') {
+      return { ok: false, reason: 'owner_process_exited', probes };
+    }
+    const ok = statusResult.ok;
     probes += 1;
     if (ok) {
-      return { ok: true, probes };
+      const currentOwnerPid = typeof ownerPid === 'function' ? ownerPid() : ownerPid;
+      if (!ownershipRequired) {
+        return { ok: true, probes };
+      }
+      if (!Number.isFinite(Number(currentOwnerPid)) || Number(currentOwnerPid) <= 1) {
+        lastOwnership = { status: 'not_owned', reason: 'owner_process_missing', listenerPids: [] };
+        // eslint-disable-next-line no-await-in-loop
+        await delayImpl(resolvedIntervalMs);
+        continue;
+      }
+      // eslint-disable-next-line no-await-in-loop
+      lastOwnership = await observeMetroListenerOwnership(
+        { port: p, ownerPid: Number(currentOwnerPid), env },
+        { listListenPidsWithStatusImpl, getProcessGroupIdImpl, isWindowsDescendantProcessImpl, platform },
+      );
+      if (lastOwnership.status === 'owned') {
+        return {
+          ok: true,
+          probes,
+          ownerPid: Number(currentOwnerPid),
+          listenerPid: lastOwnership.ownedListenerPids.includes(Number(currentOwnerPid))
+            ? Number(currentOwnerPid)
+            : lastOwnership.ownedListenerPids[0],
+          ownedListenerPids: Object.freeze([...lastOwnership.ownedListenerPids]),
+          listenerPids: lastOwnership.listenerPids,
+          port: p,
+        };
+      }
+      if (lastOwnership.status === 'not_owned') {
+        return {
+          ok: false,
+          reason: lastOwnership.reason,
+          probes,
+          listenerPids: lastOwnership.listenerPids,
+          ownedListenerPids: lastOwnership.ownedListenerPids ?? [],
+          foreignListenerPids: lastOwnership.foreignListenerPids ?? [],
+        };
+      }
     }
     // eslint-disable-next-line no-await-in-loop
     await delayImpl(resolvedIntervalMs);
   }
-  return { ok: false, reason: 'timeout', probes };
+  if (lastOwnership?.status === 'inconclusive') {
+    return {
+      ok: false,
+      reason: 'listener_ownership_inconclusive',
+      probes,
+      observation: lastOwnership.observation,
+    };
+  }
+  if (lastOwnership?.status === 'not_owned') {
+    return {
+      ok: false,
+      reason: lastOwnership.reason,
+      probes,
+      listenerPids: lastOwnership.listenerPids,
+      ownedListenerPids: lastOwnership.ownedListenerPids ?? [],
+      foreignListenerPids: lastOwnership.foreignListenerPids ?? [],
+    };
+  }
+  return { ok: false, reason: lastOwnership?.reason ?? 'timeout', probes };
 }
 
 function hashDir(dir) {
@@ -157,12 +346,74 @@ export async function readPidState(statePath) {
   }
 }
 
-export async function isStateProcessRunning(statePath) {
+async function readProcessIdentityLine(pid) {
+  const n = Number(pid);
+  if (!Number.isFinite(n) || n <= 1) return null;
+  if (process.platform === 'win32') return null;
+  if (process.platform === 'linux') {
+    const [cmdline, environ] = await Promise.all([
+      readFile(`/proc/${n}/cmdline`, 'utf-8')
+        .then((raw) => String(raw ?? '').replaceAll('\0', ' ').trim())
+        .catch(() => ''),
+      readFile(`/proc/${n}/environ`, 'utf-8')
+        .then((raw) => String(raw ?? '').replaceAll('\0', ' ').trim())
+        .catch(() => ''),
+    ]);
+    const line = `${cmdline} ${environ}`.trim();
+    return line || null;
+  }
+  try {
+    const out = await runCapture('ps', ['eww', '-p', String(n)]);
+    const lines = out.split('\n').map((l) => l.trim()).filter(Boolean);
+    if (lines.length >= 2) return lines[1];
+    if (lines.length === 1) return lines[0];
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+async function verifyStatePidIdentity({ pid, state, statePath, readProcessIdentityLineImpl = readProcessIdentityLine }) {
+  const line = await readProcessIdentityLineImpl(pid);
+  if (!line) {
+    return { ok: process.platform === 'win32', reason: 'pid_unverified' };
+  }
+
+  const expectedExpoHomeDir = join(dirname(statePath), 'expo-home');
+  const expectedExpoHomeDirs = new Set([expectedExpoHomeDir, resolve(expectedExpoHomeDir)]);
+  const expoHomeNeedle = '__UNSAFE_EXPO_HOME_DIRECTORY=';
+  if (line.includes(expoHomeNeedle)) {
+    for (const candidate of expectedExpoHomeDirs) {
+      if (line.includes(`${expoHomeNeedle}${candidate}`)) {
+        return { ok: true, reason: 'pid' };
+      }
+    }
+    return { ok: false, reason: 'pid_identity_mismatch' };
+  }
+
+  const projectDir = String(state?.projectDir ?? state?.uiDir ?? '').trim();
+  if (projectDir && line.includes(resolve(projectDir))) {
+    return { ok: true, reason: 'pid' };
+  }
+  if (projectDir) {
+    return { ok: false, reason: 'pid_identity_mismatch' };
+  }
+  return { ok: true, reason: 'pid' };
+}
+
+export async function isStateProcessRunning(
+  statePath,
+  { readProcessIdentityLineImpl = readProcessIdentityLine } = {},
+) {
   const state = await readPidState(statePath);
   if (!state) return { running: false, state: null };
   const pid = Number(state.pid);
   if (isPidAlive(pid)) {
-    return { running: true, state, reason: 'pid' };
+    const identity = await verifyStatePidIdentity({ pid, state, statePath, readProcessIdentityLineImpl });
+    if (!identity.ok) {
+      return { running: false, state, reason: identity.reason };
+    }
+    return { running: true, state, reason: identity.reason };
   }
 
   async function looksOwnedByProjectDir(port, projectDir) {
@@ -171,7 +422,9 @@ export async function isStateProcessRunning(statePath) {
     if (!Number.isFinite(p) || p <= 0) return false;
     if (!raw) return false;
     const needle = resolve(raw);
-    const pids = await listListenPids(p, { host: '127.0.0.1' }).catch(() => []);
+    const listenerObservation = await listListenPidsWithStatus(p, { timeoutMs: 4000 });
+    if (listenerObservation.status !== 'ok') return false;
+    const pids = listenerObservation.pids;
     for (const listenPid of pids) {
       // eslint-disable-next-line no-await-in-loop
       const line = await runCapture('ps', ['-o', 'command=', '-p', String(listenPid)]).catch(() => '');
@@ -211,8 +464,81 @@ export async function isStateProcessRunning(statePath) {
 }
 
 export async function writePidState(statePath, state) {
-  await mkdir(dirname(statePath), { recursive: true }).catch(() => {});
-  await writeFile(statePath, JSON.stringify(state, null, 2) + '\n', 'utf-8');
+  await withJsonOwnerFileLock(
+    () => writeJsonAtomic(statePath, state),
+    {
+      lockPath: `${statePath}.publication.lock`,
+      timeoutMs: 30_000,
+      pollIntervalMs: 50,
+      staleAfterMs: 60_000,
+      errorLabel: 'Expo PID state publication',
+    },
+  );
+}
+
+async function readExpoPidStateForMutation(statePath) {
+  try {
+    return JSON.parse(await readFile(statePath, 'utf-8'));
+  } catch (error) {
+    if (error?.code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+export async function commitExpoPidStatePublication(statePath, {
+  publicationToken,
+  expectedPreviousToken = null,
+  generation,
+  state,
+} = {}) {
+  const token = String(publicationToken ?? '').trim();
+  const expectedGeneration = Number(generation);
+  if (!token) throw new Error('[expo] missing PID publication token');
+  if (!Number.isInteger(expectedGeneration) || expectedGeneration < 1) {
+    throw new Error('[expo] invalid PID publication generation');
+  }
+  return await withJsonOwnerFileLock(async () => {
+    const current = await readExpoPidStateForMutation(statePath);
+    if ((current?.publicationToken ?? null) !== expectedPreviousToken) {
+      const error = new Error('[expo] PID state publication generation was superseded');
+      error.code = 'EEXPOPIDGENERATION';
+      throw error;
+    }
+    const next = {
+      ...(state ?? {}),
+      publicationGeneration: expectedGeneration,
+      publicationToken: token,
+    };
+    await writeJsonAtomic(statePath, next);
+    return next;
+  }, {
+    lockPath: `${statePath}.publication.lock`,
+    timeoutMs: 30_000,
+    pollIntervalMs: 50,
+    staleAfterMs: 60_000,
+    errorLabel: 'Expo PID state publication',
+  });
+}
+
+export async function restoreExpoPidStatePublication(statePath, { publicationToken, priorState } = {}) {
+  return await withJsonOwnerFileLock(async () => {
+    const current = await readExpoPidStateForMutation(statePath);
+    if (current?.publicationToken !== publicationToken) return false;
+    if (priorState == null) {
+      await unlink(statePath).catch((error) => {
+        if (error?.code !== 'ENOENT') throw error;
+      });
+    } else {
+      await writeJsonAtomic(statePath, priorState);
+    }
+    return true;
+  }, {
+    lockPath: `${statePath}.publication.lock`,
+    timeoutMs: 30_000,
+    pollIntervalMs: 50,
+    staleAfterMs: 60_000,
+    errorLabel: 'Expo PID state rollback',
+  });
 }
 
 export async function findRunningExpoStateInRoot({ expoDevRoot, requireWeb = false, expectedProjectDir = '' } = {}) {