oh-my-customcode 1.1.102 → 1.1.104

package/dist/cli/index.js

@@ -335,7 +335,7 @@ var init_package = __esm(() => {
     workspaces: [
       "packages/*"
     ],
-    version: "1.1.102",
+    version: "1.1.104",
     description: "Batteries-included agent harness for Claude Code",
     type: "module",
     bin: {
@@ -14666,12 +14666,16 @@ var en_default = {
         started: "Web UI started: http://localhost:{{port}}",
         failed: "Failed to start Web UI server",
         homeUnresolved: "Cannot start the Web UI server: the home directory cannot be resolved, either because HOME is a relative path or because HOME, the OS-reported home and the passwd entry are all empty, so the PID file location cannot be determined. Set HOME to an absolute path.",
-        pidNotWritable: "Cannot start the Web UI server: the PID file {{path}} cannot be written ({{error}}). Check the PID file path and its parent directory."
+        pidNotWritable: "Cannot start the Web UI server: the PID file {{path}} cannot be written ({{error}}). Check the PID file path and its parent directory.",
+        alreadyRunning: "Web UI server is already running (PID {{pid}}); no new server was started. Its port is not recorded — check the port you started it with.",
+        alreadyRunningNotPermitted: "The PID file records PID {{pid}}, which belongs to another user, so this command cannot tell whether it is the Web UI server; no new server was started. If no omcustom Web UI server is running, delete the PID file ({{path}}) and try again.",
+        startingElsewhere: "Another Web UI start is in progress; this command did not start a server."
       },
       stop: {
         description: "Stop the Web UI server",
         stopped: "Web UI server stopped",
-        notRunning: "Web UI server is not running"
+        notRunning: "Web UI server is not running",
+        notPermitted: "Cannot stop the Web UI server: process {{pid}} recorded in {{path}} exists but you are not permitted to signal it. It belongs to another user, or the PID file is stale and the PID was reused by an unrelated process. Stop it as that user, or remove the PID file if it is stale."
       },
       status: {
         description: "Show Web UI server status",
@@ -15086,12 +15090,16 @@ var ko_default = {
         started: "Web UI 시작됨: http://localhost:{{port}}",
         failed: "Web UI 서버 시작 실패",
         homeUnresolved: "Web UI 서버를 시작할 수 없습니다: 홈 디렉토리를 확인할 수 없어 PID 파일 위치를 정할 수 없습니다. HOME이 상대 경로이거나, HOME·OS 보고 홈·passwd 항목이 모두 비어 있는 경우입니다. HOME을 절대 경로로 설정하세요.",
-        pidNotWritable: "Web UI 서버를 시작할 수 없습니다: PID 파일 {{path}}에 쓸 수 없습니다 ({{error}}). PID 파일 경로와 그 상위 디렉토리를 확인하세요."
+        pidNotWritable: "Web UI 서버를 시작할 수 없습니다: PID 파일 {{path}}에 쓸 수 없습니다 ({{error}}). PID 파일 경로와 그 상위 디렉토리를 확인하세요.",
+        alreadyRunning: "Web UI 서버가 이미 실행 중입니다 (PID {{pid}}). 새 서버를 시작하지 않았습니다. 서버의 포트는 기록되지 않으므로 시작할 때 지정한 포트를 확인하세요.",
+        alreadyRunningNotPermitted: "PID 파일에 기록된 PID {{pid}}는 다른 사용자의 프로세스라서 Web UI 서버인지 이 명령으로 확인할 수 없습니다. 새 서버를 시작하지 않았습니다. omcustom Web UI 서버가 실행 중이 아니라면 PID 파일({{path}})을 삭제한 뒤 다시 시도하세요.",
+        startingElsewhere: "다른 Web UI 시작이 진행 중입니다. 이 명령은 서버를 시작하지 않았습니다."
       },
       stop: {
         description: "Web UI 서버 중지",
         stopped: "Web UI 서버가 중지되었습니다",
-        notRunning: "Web UI 서버가 실행 중이 아닙니다"
+        notRunning: "Web UI 서버가 실행 중이 아닙니다",
+        notPermitted: "Web UI 서버를 중지할 수 없습니다: {{path}}에 기록된 프로세스 {{pid}}가 존재하지만 신호를 보낼 권한이 없습니다. 다른 사용자의 프로세스이거나, PID 파일이 오래되어 PID가 무관한 프로세스에 재사용된 경우입니다. 해당 사용자로 중지하거나, 오래된 PID 파일이면 삭제하세요."
       },
       status: {
         description: "Web UI 서버 상태 표시",
@@ -15786,6 +15794,7 @@ var MESSAGES = {
     "lockfile.component_dir_missing": "Component directory missing: {{path}}",
     "lockfile.hash_failed": "Failed to hash file: {{path}} — {{error}}",
     "lockfile.entry_added": "Lockfile entry added: {{path}} ({{component}})",
+    "lockfile.entry_git_excluded": "Lockfile entry skipped (not in git listing): {{path}}",
     "update.start": "Checking for updates...",
     "update.success": "Updated from {{from}} to {{to}}",
     "update.components_synced": "Components synced (version {{version}}): {{components}}",
@@ -15907,6 +15916,7 @@ var MESSAGES = {
     "lockfile.component_dir_missing": "컴포넌트 디렉토리 없음: {{path}}",
     "lockfile.hash_failed": "파일 해시 실패: {{path}} — {{error}}",
     "lockfile.entry_added": "잠금 파일 항목 추가: {{path}} ({{component}})",
+    "lockfile.entry_git_excluded": "잠금 파일 항목 제외 (git 목록에 없음): {{path}}",
     "update.start": "업데이트 확인 중...",
     "update.success": "{{from}}에서 {{to}}로 업데이트 완료",
     "update.components_synced": "컴포넌트 동기화 완료 (버전 {{version}}): {{components}}",
@@ -16362,10 +16372,12 @@ function getComponentPath(component) {
 
 // src/core/lockfile.ts
 init_fs();
+import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
-import { readdir, stat } from "node:fs/promises";
+import { readdir, realpath, stat } from "node:fs/promises";
 import { join as join7, relative as relative2 } from "node:path";
+import { promisify } from "node:util";
 var LOCKFILE_NAME = ".omcustom.lock.json";
 var LOCKFILE_VERSION = 1;
 var LOCKFILE_COMPONENTS = [
@@ -16378,6 +16390,87 @@ var LOCKFILE_COMPONENTS = [
   "guides"
 ];
 var COMPONENT_PATHS = LOCKFILE_COMPONENTS.map((component) => [getComponentPath(component), component]);
+var execFileAsync = promisify(execFile);
+var GIT_LOCATION_ENV_KEYS = [
+  "GIT_DIR",
+  "GIT_WORK_TREE",
+  "GIT_INDEX_FILE",
+  "GIT_PREFIX",
+  "GIT_COMMON_DIR"
+];
+var GIT_INJECTED_CONFIG_ENV_KEYS = ["GIT_CONFIG_PARAMETERS", "GIT_CONFIG_COUNT"];
+var GIT_INJECTED_CONFIG_ENV_PREFIXES = ["GIT_CONFIG_KEY_", "GIT_CONFIG_VALUE_"];
+var GIT_REQUIRED_HINT = "build from a git checkout: excluding ignored local files from the lockfile requires git (#1819)";
+function gitChildEnv() {
+  const env = { ...process.env };
+  for (const key of [...GIT_LOCATION_ENV_KEYS, ...GIT_INJECTED_CONFIG_ENV_KEYS]) {
+    delete env[key];
+  }
+  for (const key of Object.keys(env)) {
+    if (GIT_INJECTED_CONFIG_ENV_PREFIXES.some((prefix) => key.startsWith(prefix))) {
+      delete env[key];
+    }
+  }
+  return env;
+}
+async function runGit(targetDir, args, env) {
+  try {
+    const { stdout } = await execFileAsync("git", args, {
+      cwd: targetDir,
+      env,
+      encoding: "utf-8",
+      maxBuffer: 256 * 1024 * 1024
+    });
+    return stdout;
+  } catch (err) {
+    const detail = err instanceof Error ? err.message.trim() : String(err);
+    throw new Error(`git ${args[0]} failed in ${targetDir}: ${detail} — ${GIT_REQUIRED_HINT}`);
+  }
+}
+function foldCase(nfcPath) {
+  return nfcPath.toLowerCase();
+}
+function isGitVisible(visible, relativePath) {
+  if (visible.exact.has(relativePath)) {
+    return true;
+  }
+  const nfc = relativePath.normalize("NFC");
+  if (visible.nfc.has(nfc)) {
+    return true;
+  }
+  return visible.folded?.has(foldCase(nfc)) ?? false;
+}
+function stripFinalNewline(output) {
+  return output.endsWith(`
+`) ? output.slice(0, -1) : output;
+}
+async function assertGitWorkTreeRoot(targetDir, env) {
+  const topLevel = stripFinalNewline(await runGit(targetDir, ["rev-parse", "--show-toplevel"], env));
+  let realTop;
+  let realTarget;
+  try {
+    [realTop, realTarget] = await Promise.all([realpath(topLevel), realpath(targetDir)]);
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new Error(`cannot resolve the git work tree root of ${targetDir}: ${detail} — ${GIT_REQUIRED_HINT}`);
+  }
+  if (realTop !== realTarget) {
+    throw new Error(`${targetDir} is not the root of its git work tree (root: ${topLevel}) — ${GIT_REQUIRED_HINT}`);
+  }
+}
+async function listGitVisiblePaths(targetDir) {
+  const env = gitChildEnv();
+  await assertGitWorkTreeRoot(targetDir, env);
+  const pathspecs = COMPONENT_PATHS.map(([prefix]) => prefix);
+  const [listing, ignoreCase] = await Promise.all([
+    runGit(targetDir, ["ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", ...pathspecs], env),
+    runGit(targetDir, ["config", "--type=bool", "--default=false", "--get", "core.ignorecase"], env)
+  ]);
+  const exact = new Set(listing.split("\x00").filter((entry) => entry.length > 0));
+  const nfc = new Set([...exact].map((entry) => entry.normalize("NFC")));
+  const folded = stripFinalNewline(ignoreCase) === "true" ? new Set([...nfc].map(foldCase)) : null;
+  return { exact, nfc, folded };
+}
 function computeFileHash(filePath) {
   return new Promise((resolve, reject) => {
     const hash = createHash("sha256");
@@ -16463,8 +16556,9 @@ function sortFilesByPath(files) {
   const sorted = Object.keys(files).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
   return Object.fromEntries(sorted.map((key) => [key, files[key]]));
 }
-async function generateLockfile(targetDir, generatorVersion, templateVersion) {
+async function generateLockfile(targetDir, generatorVersion, templateVersion, options = {}) {
   const files = {};
+  const gitVisible = options.excludeGitIgnored ? await listGitVisiblePaths(targetDir) : null;
   const componentRoots = COMPONENT_PATHS.map(([prefix]) => join7(targetDir, prefix));
   for (const componentRoot of componentRoots) {
     const exists = await fileExists(componentRoot);
@@ -16475,6 +16569,10 @@ async function generateLockfile(targetDir, generatorVersion, templateVersion) {
     const allFiles = await collectFiles(componentRoot, targetDir, false);
     for (const absolutePath of allFiles) {
       const relativePath = relative2(targetDir, absolutePath).replace(/\\/g, "/");
+      if (gitVisible !== null && !isGitVisible(gitVisible, relativePath)) {
+        debug("lockfile.entry_git_excluded", { path: relativePath });
+        continue;
+      }
       let hash;
       let size;
       try {
@@ -16535,12 +16633,12 @@ function preserveGeneratedAt(next, previous) {
   }
   return { ...next, generatedAt: previous.generatedAt };
 }
-async function generateAndWriteLockfileForDir(targetDir) {
+async function generateAndWriteLockfileForDir(targetDir, options = {}) {
   try {
     const packageRoot = getPackageRoot();
     const manifest = await readJsonFile(join7(packageRoot, "templates", "manifest.json"));
     const { version: generatorVersion } = await readJsonFile(join7(packageRoot, "package.json"));
-    const generated = await generateLockfile(targetDir, generatorVersion, manifest.version);
+    const generated = await generateLockfile(targetDir, generatorVersion, manifest.version, options);
     const previous = await readLockfile(targetDir);
     const lockfile = preserveGeneratedAt(generated, previous);
     await writeLockfile(targetDir, lockfile);
@@ -20938,11 +21036,31 @@ import { join as join17 } from "node:path";
 // src/cli/serve.ts
 init_home();
 import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { constants as constants3, existsSync as existsSync3 } from "node:fs";
-import { access, readFile as readFile3, unlink, writeFile as writeFile3 } from "node:fs/promises";
+import {
+  access,
+  link,
+  readdir as readdir3,
+  readFile as readFile3,
+  readlink,
+  rename as rename2,
+  stat as stat3,
+  unlink,
+  writeFile as writeFile3
+} from "node:fs/promises";
 import { dirname as dirname7, isAbsolute as isAbsolute4, join as join16 } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
 var DEFAULT_PORT = 4321;
 var PID_FILE_NAME = ".omcustom-serve.pid";
+var STARTING_RECORD = /^starting:(\d+):/;
+var MAX_PID = 2147483647;
+var MAX_CLAIM_ATTEMPTS = 3;
+var CLAIM_MAX_AGE_MS = 60000;
+var PARTIAL_RECORD_GRACE_MS = 1e4;
+var ABSENT_RETRY_DELAY_MS = 10;
+var HARD_LINK_UNSUPPORTED = new Set(["ENOTSUP", "EOPNOTSUPP", "EPERM", "EXDEV"]);
+var SIBLING_REMNANT = /^\.omcustom-serve\.pid\.(\d+)\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.(?:tmp|taken)$/;
 
 class ServePidFileError extends Error {
   reason;
@@ -20954,6 +21072,17 @@ class ServePidFileError extends Error {
     this.pidFile = pidFile;
   }
 }
+
+class ServeStopPermissionError extends Error {
+  pid;
+  pidFile;
+  constructor(pid, pidFile, options) {
+    super(`Not permitted to signal the serve process ${pid} recorded in ${pidFile}`, options);
+    this.name = "ServeStopPermissionError";
+    this.pid = pid;
+    this.pidFile = pidFile;
+  }
+}
 function resolveServePidFile(sources) {
   const home = resolveHomeDir(sources);
   if (!isAbsolute4(home)) {
@@ -20966,12 +21095,65 @@ function findServeBuildDir(projectRoot, options) {
   if (existsSync3(join16(localBuild, "index.js")))
     return localBuild;
   if (options?.skipNpmFallback !== true) {
-    const npmBuild = join16(import.meta.dirname, "..", "..", "packages", "serve", "build");
+    const npmPackageRoot = options?.npmPackageRoot ?? join16(import.meta.dirname, "..", "..");
+    const npmBuild = join16(npmPackageRoot, "packages", "serve", "build");
     if (existsSync3(join16(npmBuild, "index.js")))
       return npmBuild;
   }
   return null;
 }
+function parsePidRecord(raw) {
+  const text = raw.trim();
+  const match = STARTING_RECORD.exec(text);
+  const pid = Number(match === null ? text : match[1]);
+  if (!Number.isSafeInteger(pid) || pid <= 0 || pid > MAX_PID) {
+    return null;
+  }
+  return { pid, starting: match !== null };
+}
+function probeProcess(pid) {
+  try {
+    process.kill(pid, 0);
+    return "exists";
+  } catch (error) {
+    const code = errorCode(error);
+    if (code === "ESRCH") {
+      return "gone";
+    }
+    return code === "EPERM" ? "not-permitted" : "unknown";
+  }
+}
+function isProcessAlive(pid) {
+  return probeProcess(pid) !== "gone";
+}
+function errorCode(error) {
+  return error?.code;
+}
+async function isOlderThan(path, ms) {
+  try {
+    const { mtimeMs } = await stat3(path);
+    return Date.now() - mtimeMs >= ms;
+  } catch {
+    return false;
+  }
+}
+async function isRecordLive(pidFile, record) {
+  if (!isProcessAlive(record.pid)) {
+    return false;
+  }
+  return !record.starting || !await isOlderThan(pidFile, CLAIM_MAX_AGE_MS);
+}
+async function readPidFileSettled(pidFile) {
+  try {
+    return await readFile3(pidFile, "utf-8");
+  } catch (error) {
+    if (errorCode(error) !== "ENOENT") {
+      throw error;
+    }
+  }
+  await delay(ABSENT_RETRY_DELAY_MS);
+  return readFile3(pidFile, "utf-8");
+}
 async function isServeRunning() {
   const pidFile = resolveServePidFile();
   if (pidFile === null) {
@@ -20980,37 +21162,64 @@ async function isServeRunning() {
   return isServeRunningAt(pidFile);
 }
 async function isServeRunningAt(pidFile) {
+  return await readLiveRecord(pidFile) !== null;
+}
+async function readLiveRecord(pidFile) {
+  let raw;
   try {
-    const raw = await readFile3(pidFile, "utf-8");
-    const pid = Number(raw.trim());
-    if (!Number.isFinite(pid) || pid <= 0) {
-      await cleanupPidFile(pidFile);
-      return false;
-    }
-    process.kill(pid, 0);
-    return true;
+    raw = await readPidFileSettled(pidFile);
   } catch {
-    await cleanupPidFile(pidFile);
-    return false;
+    return null;
+  }
+  const record = parsePidRecord(raw);
+  return record !== null && await isRecordLive(pidFile, record) ? record : null;
+}
+function heldResult(record) {
+  if (record === null || record.starting) {
+    return { status: "starting-elsewhere" };
+  }
+  const probe = probeProcess(record.pid);
+  if (probe === "gone") {
+    return { status: "starting-elsewhere" };
   }
+  return probe === "not-permitted" ? { status: "already-running", pid: record.pid, notPermitted: true } : { status: "already-running", pid: record.pid };
+}
+async function getServerPid() {
+  const pidFile = resolveServePidFile();
+  if (pidFile === null) {
+    return null;
+  }
+  const record = await readLiveRecord(pidFile);
+  return record !== null && !record.starting ? record.pid : null;
 }
 async function startServeBackground(projectRoot, port = DEFAULT_PORT, buildDirOpts) {
   const pidFile = resolveServePidFile();
   if (pidFile === null) {
     throw new ServePidFileError("home-unresolved", null);
   }
-  if (await isServeRunningAt(pidFile)) {
-    return;
+  const running = await readLiveRecord(pidFile);
+  if (running !== null) {
+    return heldResult(running);
   }
   const buildDir = findServeBuildDir(projectRoot, buildDirOpts);
   if (buildDir === null) {
-    return;
+    return { status: "build-missing" };
   }
   try {
     await access(dirname7(pidFile), constants3.W_OK);
   } catch (error) {
     throw new ServePidFileError("pid-not-writable", pidFile, { cause: error });
   }
+  let claimed;
+  try {
+    claimed = await claimPidFile(pidFile);
+  } catch (error) {
+    throw new ServePidFileError("pid-not-writable", pidFile, { cause: error });
+  }
+  if ("held" in claimed) {
+    return heldResult(claimed.held);
+  }
+  const { claim } = claimed;
   const child = spawn("node", [join16(buildDir, "index.js")], {
     env: {
       ...process.env,
@@ -21025,38 +21234,214 @@ async function startServeBackground(projectRoot, port = DEFAULT_PORT, buildDirOp
   child.on("error", () => {});
   child.unref();
   if (child.pid === undefined) {
-    return;
+    await removePidFileIf(pidFile, claim);
+    return { status: "spawn-failed" };
   }
+  let outcome;
   try {
-    await writeFile3(pidFile, String(child.pid), "utf-8");
+    outcome = await recordServerPid(pidFile, claim, String(child.pid));
   } catch (error) {
     child.kill("SIGTERM");
+    await removePidFileIf(pidFile, claim);
     throw new ServePidFileError("pid-not-writable", pidFile, { cause: error });
   }
+  if (!outcome.recorded) {
+    child.kill("SIGTERM");
+    return heldResult(outcome.lost);
+  }
+  return { status: "started", pid: child.pid };
+}
+async function recordServerPid(pidFile, claim, pid) {
+  for (let attempt = 0;attempt < MAX_CLAIM_ATTEMPTS; attempt++) {
+    if (await createPidFileExclusive(pidFile, pid)) {
+      return { recorded: true };
+    }
+    let current;
+    try {
+      current = await readFile3(pidFile, "utf-8");
+    } catch (error) {
+      if (errorCode(error) === "ENOENT") {
+        continue;
+      }
+      throw error;
+    }
+    if (current !== claim) {
+      return { recorded: false, lost: parsePidRecord(current) };
+    }
+    await replacePidFile(pidFile, pid);
+    return { recorded: true };
+  }
+  return { recorded: false, lost: null };
 }
 async function stopServe() {
   const pidFile = resolveServePidFile();
   if (pidFile === null) {
     return false;
   }
+  let raw;
   try {
-    const raw = await readFile3(pidFile, "utf-8");
-    const pid = Number(raw.trim());
-    if (!Number.isFinite(pid) || pid <= 0) {
-      await cleanupPidFile(pidFile);
-      return false;
+    raw = await readPidFileSettled(pidFile);
+  } catch {
+    return false;
+  }
+  const record = parsePidRecord(raw);
+  if (record === null || record.starting) {
+    return false;
+  }
+  try {
+    process.kill(record.pid, "SIGTERM");
+  } catch (error) {
+    if (errorCode(error) === "EPERM") {
+      throw new ServeStopPermissionError(record.pid, pidFile, { cause: error });
+    }
+    return false;
+  }
+  await removePidFileIf(pidFile, raw);
+  return true;
+}
+function siblingPath(pidFile, suffix) {
+  return `${pidFile}.${process.pid}.${randomUUID()}.${suffix}`;
+}
+async function claimPidFile(pidFile) {
+  await removeDeadSiblings(pidFile);
+  const claim = `starting:${process.pid}:${randomUUID()}`;
+  for (let attempt = 0;attempt < MAX_CLAIM_ATTEMPTS; attempt++) {
+    if (await createPidFileExclusive(pidFile, claim)) {
+      return { claim };
+    }
+    let raw;
+    try {
+      raw = await readFile3(pidFile, "utf-8");
+    } catch (error) {
+      if (errorCode(error) === "ENOENT") {
+        await removeDanglingLink(pidFile);
+        continue;
+      }
+      throw error;
+    }
+    if (await isRecordHeld(pidFile, raw)) {
+      return { held: parsePidRecord(raw) };
     }
-    process.kill(pid, "SIGTERM");
-    await cleanupPidFile(pidFile);
+    await removePidFileIf(pidFile, raw);
+  }
+  return { held: null };
+}
+async function isRecordHeld(pidFile, raw) {
+  const record = parsePidRecord(raw);
+  if (record === null) {
+    return isPossiblyPartialRecord(raw) && !await isOlderThan(pidFile, PARTIAL_RECORD_GRACE_MS);
+  }
+  return isRecordLive(pidFile, record);
+}
+function isPossiblyPartialRecord(raw) {
+  return "starting:".startsWith(raw) || /^starting:\d*$/.test(raw);
+}
+async function removeDeadSiblings(pidFile) {
+  const dir = dirname7(pidFile);
+  let names;
+  try {
+    names = await readdir3(dir);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    const match = SIBLING_REMNANT.exec(name);
+    if (match !== null && !isProcessAlive(Number(match[1]))) {
+      await unlinkQuietly(join16(dir, name));
+    }
+  }
+}
+async function createPidFileExclusive(pidFile, content) {
+  const staged = siblingPath(pidFile, "tmp");
+  try {
+    await writeFile3(staged, content, { encoding: "utf-8", flag: "wx" });
+    await linkExclusive(staged, pidFile, content);
     return true;
+  } catch (error) {
+    if (errorCode(error) === "EEXIST") {
+      return false;
+    }
+    throw error;
+  } finally {
+    await unlinkQuietly(staged);
+  }
+}
+async function linkExclusive(source, target, content) {
+  try {
+    await link(source, target);
+  } catch (error) {
+    if (!HARD_LINK_UNSUPPORTED.has(errorCode(error) ?? "")) {
+      throw error;
+    }
+    await writeFile3(target, content, { encoding: "utf-8", flag: "wx" });
+  }
+}
+async function replacePidFile(pidFile, content) {
+  const staged = siblingPath(pidFile, "tmp");
+  try {
+    await writeFile3(staged, content, { encoding: "utf-8", flag: "wx" });
+    await rename2(staged, pidFile);
+  } catch (error) {
+    await unlinkQuietly(staged);
+    throw error;
+  }
+}
+async function removePidFileIf(pidFile, expected) {
+  await removePidFileWhen(pidFile, async (taken) => {
+    try {
+      return await readFile3(taken, "utf-8") === expected;
+    } catch {
+      return false;
+    }
+  });
+}
+async function removeDanglingLink(pidFile) {
+  if (!await isDanglingLink(pidFile)) {
+    return;
+  }
+  await removePidFileWhen(pidFile, isDanglingLink);
+}
+async function isDanglingLink(path) {
+  try {
+    await readlink(path);
   } catch {
-    await cleanupPidFile(pidFile);
     return false;
   }
+  try {
+    await stat3(path);
+    return false;
+  } catch {
+    return true;
+  }
 }
-async function cleanupPidFile(pidFile) {
+async function removePidFileWhen(pidFile, isExpected) {
+  const taken = siblingPath(pidFile, "taken");
   try {
-    await unlink(pidFile);
+    await rename2(pidFile, taken);
+  } catch {
+    return;
+  }
+  if (!await isExpected(taken)) {
+    await putBack(taken, pidFile);
+  }
+  await unlinkQuietly(taken);
+}
+async function putBack(taken, pidFile) {
+  try {
+    await link(taken, pidFile);
+    return;
+  } catch (error) {
+    if (!HARD_LINK_UNSUPPORTED.has(errorCode(error) ?? "")) {
+      return;
+    }
+  }
+  try {
+    await writeFile3(pidFile, await readFile3(taken, "utf-8"), { encoding: "utf-8", flag: "wx" });
+  } catch {}
+}
+async function unlinkQuietly(path) {
+  try {
+    await unlink(path);
   } catch {}
 }
 
@@ -21075,8 +21460,9 @@ async function serveCommand(options) {
     runForeground(cwd, port, buildDirOpts);
     return;
   }
+  let result;
   try {
-    await startServeBackground(cwd, port, buildDirOpts);
+    result = await startServeBackground(cwd, port, buildDirOpts);
   } catch (error) {
     if (!(error instanceof ServePidFileError)) {
       throw error;
@@ -21084,8 +21470,22 @@ async function serveCommand(options) {
     console.error(describePidFileError(error));
     process.exit(1);
   }
-  const running = await isServeRunning();
-  if (running) {
+  switch (result.status) {
+    case "already-running":
+      console.log(result.notPermitted === true ? i18n.t("cli.web.start.alreadyRunningNotPermitted", {
+        pid: result.pid,
+        path: String(resolveServePidFile())
+      }) : i18n.t("cli.web.start.alreadyRunning", { pid: result.pid }));
+      return;
+    case "starting-elsewhere":
+      console.log(i18n.t("cli.web.start.startingElsewhere"));
+      return;
+    case "build-missing":
+    case "spawn-failed":
+      console.error(i18n.t("cli.web.start.failed"));
+      process.exit(1);
+  }
+  if (await getServerPid() === result.pid) {
     console.log(i18n.t("cli.web.start.started", { port }));
   } else {
     console.error(i18n.t("cli.web.start.failed"));
@@ -21100,7 +21500,16 @@ function describePidFileError(error) {
   return i18n.t("cli.web.start.pidNotWritable", { path: String(error.pidFile), error: cause });
 }
 async function serveStopCommand() {
-  const stopped = await stopServe();
+  let stopped;
+  try {
+    stopped = await stopServe();
+  } catch (error) {
+    if (!(error instanceof ServeStopPermissionError)) {
+      throw error;
+    }
+    console.error(i18n.t("cli.web.stop.notPermitted", { pid: error.pid, path: error.pidFile }));
+    process.exit(1);
+  }
   if (stopped) {
     console.log(i18n.t("cli.web.stop.stopped"));
   } else {