Merge remote-tracking branch 'upstream/main' into codex/pr-93446-conflict-repair

fuller-stack-dev · fuller-stack-dev · commit e6abe1f5a7e9 · 2026-06-15T21:11:46.000-06:00
diff --git a/src/cli/gateway-cli/run.option-collisions.test.ts b/src/cli/gateway-cli/run.option-collisions.test.ts
@@ -21,7 +21,9 @@ const forceFreePortAndWait = vi.fn(async (_port: number, _opts: unknown) => ({
   waitedMs: 0,
   escalatedToSigkill: false,
 }));
-const cleanStaleGatewayProcessesSync = vi.fn((_port?: number) => []);
+const cleanStaleGatewayProcessesSync = vi.fn(
+  (_port?: number, _options?: { protectedPid?: number }) => [],
+);
 const waitForPortBindable = vi.fn(async (_port: number, _opts?: unknown) => 0);
 const ensureDevGatewayConfig = vi.fn(async (_opts?: unknown) => {});
 type GatewayLoopStart = (params?: { startupStartedAt?: number }) => Promise<unknown>;
@@ -193,7 +195,8 @@ vi.mock("../../gateway/net.js", async (importOriginal) => {
 });
 
 vi.mock("../../infra/restart-stale-pids.js", () => ({
-  cleanStaleGatewayProcessesSync: (port?: number) => cleanStaleGatewayProcessesSync(port),
+  cleanStaleGatewayProcessesSync: (port?: number, options?: { protectedPid?: number }) =>
+    cleanStaleGatewayProcessesSync(port, options),
 }));
 
 vi.mock("../../gateway/server.js", () => ({
@@ -823,6 +826,23 @@ describe("gateway run option collisions", () => {
     expect(normalizeStateDirEnv).toHaveBeenCalledWith(process.env);
   });
 
+  it("protects the inherited service pid before replacing it", async () => {
+    await withEnvAsync(
+      {
+        OPENCLAW_SERVICE_MARKER: "openclaw",
+        [GATEWAY_SERVICE_RUNTIME_PID_ENV]: "4242",
+      },
+      async () => {
+        await runGatewayCli(["gateway", "run", "--allow-unconfigured"]);
+
+        expect(cleanStaleGatewayProcessesSync).toHaveBeenCalledWith(18789, {
+          protectedPid: 4242,
+        });
+        expect(process.env[GATEWAY_SERVICE_RUNTIME_PID_ENV]).toBe(String(process.pid));
+      },
+    );
+  });
+
   it("marks descendants when the final config supplies the service marker", async () => {
     await withEnvAsync(
       {
diff --git a/src/cli/gateway-cli/run.ts b/src/cli/gateway-cli/run.ts
@@ -35,6 +35,7 @@ import { setVerbose } from "../../globals.js";
 import { isTruthyEnvValue } from "../../infra/env.js";
 import { formatErrorMessage } from "../../infra/errors.js";
 import { GatewayLockError } from "../../infra/gateway-lock.js";
+import { parseStrictPositiveInteger } from "../../infra/parse-finite-number.js";
 import type { RespawnSupervisor } from "../../infra/supervisor-markers.js";
 import { setConsoleSubsystemFilter, setConsoleTimestampPrefix } from "../../logging/console.js";
 import { withDiagnosticPhase } from "../../logging/diagnostic-phase.js";
@@ -561,6 +562,11 @@ async function maybeWriteGatewayStartupFailureBundle(err: unknown): Promise<void
 }
 
 export async function runGatewayCommand(opts: GatewayRunOpts, hooks: GatewayRunRuntimeHooks = {}) {
+  // Reparenting can hide the running service from the ancestor walk.
+  // Preserve its inherited PID before config env rebuilding overwrites it.
+  const inheritedGatewayServicePid = parseStrictPositiveInteger(
+    process.env[GATEWAY_SERVICE_RUNTIME_PID_ENV],
+  );
   normalizeStateDirEnv(process.env);
   const { clearGatewayRunConfigEnvironment } = await import("./pre-bootstrap.js");
   clearGatewayRunConfigEnvironment();
@@ -716,7 +722,9 @@ export async function runGatewayCommand(opts: GatewayRunOpts, hooks: GatewayRunR
   const bindExplicitRaw = bindExplicitRawStr as GatewayBindMode | undefined;
   if (process.env.OPENCLAW_SERVICE_MARKER?.trim()) {
     const { cleanStaleGatewayProcessesSync } = await import("../../infra/restart-stale-pids.js");
-    const stale = cleanStaleGatewayProcessesSync(port);
+    const stale = cleanStaleGatewayProcessesSync(port, {
+      protectedPid: inheritedGatewayServicePid,
+    });
     if (stale.length > 0) {
       gatewayLog.info(
         `service-mode: cleared ${stale.length} stale gateway pid(s) before bind on port ${port}`,
diff --git a/src/infra/restart-stale-pids.test.ts b/src/infra/restart-stale-pids.test.ts
@@ -798,6 +798,32 @@ describe.skipIf(isWindows)("restart-stale-pids", () => {
       expect(killSpy).toHaveBeenCalledWith(stalePid, "SIGTERM");
     });
 
+    it("does not kill a protected gateway pid after reparenting", () => {
+      const protectedPid = process.pid + 4001;
+      const stalePid = process.pid + 4002;
+      let lsofCall = 0;
+      mockSpawnSync.mockImplementation(() => {
+        lsofCall += 1;
+        return lsofCall === 1
+          ? createLsofResult({
+              stdout: lsofOutput([
+                { pid: protectedPid, cmd: "openclaw-gateway" },
+                { pid: stalePid, cmd: "openclaw-gateway" },
+              ]),
+            })
+          : createLsofResult({ status: 1 });
+      });
+      const killSpy = vi.spyOn(process, "kill").mockReturnValue(true);
+
+      const result = withStubbedPpid(1, () =>
+        cleanStaleGatewayProcessesSync(18789, { protectedPid }),
+      );
+
+      expect(result).toEqual([stalePid]);
+      expect(killSpy).toHaveBeenCalledWith(stalePid, "SIGTERM");
+      expect(killSpy).not.toHaveBeenCalledWith(protectedPid, expect.anything());
+    });
+
     it("escalates to SIGKILL when process survives the SIGTERM window", () => {
       const stalePid = process.pid + 101;
       let call = 0;
diff --git a/src/infra/restart-stale-pids.ts b/src/infra/restart-stale-pids.ts
@@ -187,6 +187,15 @@ export function getSelfAndAncestorPidsSync(spawnTimeoutMs = SPAWN_TIMEOUT_MS): S
   return pids;
 }
 
+function getExcludedGatewayPidsSync(spawnTimeoutMs: number, protectedPid?: number): Set<number> {
+  const excluded = getSelfAndAncestorPidsSync(spawnTimeoutMs);
+  if (typeof protectedPid === "number" && Number.isSafeInteger(protectedPid) && protectedPid > 0) {
+    // A reparented service can become a sibling and disappear from the ancestor walk.
+    excluded.add(protectedPid);
+  }
+  return excluded;
+}
+
 /**
  * Parse raw PIDs from lsof -Fpc stdout, excluding the current
  * process and its ancestors (see `getSelfAndAncestorPidsSync` for the full
@@ -257,12 +266,16 @@ function verifyGatewayPidByArgvSync(pid: number, spawnTimeoutMs: number): boolea
   return args != null && isGatewayArgv(args, { allowGatewayBinary: true });
 }
 
-function parsePidsFromLsofOutput(stdout: string, spawnTimeoutMs: number): number[] {
+function parsePidsFromLsofOutput(
+  stdout: string,
+  spawnTimeoutMs: number,
+  protectedPid?: number,
+): number[] {
   // Deduplicate: dual-stack listeners (IPv4 + IPv6) cause lsof to emit the
   // same PID twice. Return each PID at most once to avoid double-killing.
   // Exclude self and ancestors — terminating any ancestor cascade-kills the
   // caller via the supervisor, recreating the #68451 restart loop.
-  const excluded = getSelfAndAncestorPidsSync(spawnTimeoutMs);
+  const excluded = getExcludedGatewayPidsSync(spawnTimeoutMs, protectedPid);
   const pids: number[] = [];
   for (const entry of parseLsofEntries(stdout)) {
     if (excluded.has(entry.pid)) {
@@ -285,8 +298,8 @@ function parsePidsFromLsofOutput(stdout: string, spawnTimeoutMs: number): number
  * and its ancestors (same invariant as the lsof path — see
  * `getSelfAndAncestorPidsSync`).
  */
-function filterVerifiedWindowsGatewayPids(rawPids: number[]): number[] {
-  const excluded = getSelfAndAncestorPidsSync();
+function filterVerifiedWindowsGatewayPids(rawPids: number[], protectedPid?: number): number[] {
+  const excluded = getExcludedGatewayPidsSync(SPAWN_TIMEOUT_MS, protectedPid);
   return uniqueValues(rawPids)
     .filter((pid) => Number.isFinite(pid) && pid > 0 && !excluded.has(pid))
     .filter((pid) => {
@@ -298,8 +311,9 @@ function filterVerifiedWindowsGatewayPids(rawPids: number[]): number[] {
 function filterVerifiedWindowsGatewayPidsResult(
   rawPids: number[],
   processArgsResult: (pid: number) => WindowsProcessArgsResult,
+  protectedPid?: number,
 ): WindowsListeningPidsResult {
-  const excluded = getSelfAndAncestorPidsSync();
+  const excluded = getExcludedGatewayPidsSync(SPAWN_TIMEOUT_MS, protectedPid);
   const verified: number[] = [];
   for (const pid of uniqueValues(rawPids)) {
     if (!Number.isFinite(pid) || pid <= 0 || excluded.has(pid)) {
@@ -316,32 +330,34 @@ function filterVerifiedWindowsGatewayPidsResult(
   return { ok: true, pids: verified };
 }
 
-function findVerifiedWindowsGatewayPidsOnPortSync(port: number): number[] {
-  return filterVerifiedWindowsGatewayPids(readWindowsListeningPidsOnPortSync(port));
+function findVerifiedWindowsGatewayPidsOnPortSync(port: number, protectedPid?: number): number[] {
+  return filterVerifiedWindowsGatewayPids(readWindowsListeningPidsOnPortSync(port), protectedPid);
 }
 
-function findVerifiedWindowsGatewayPidsOnPortResultSync(port: number): WindowsListeningPidsResult {
+function findVerifiedWindowsGatewayPidsOnPortResultSync(
+  port: number,
+  protectedPid?: number,
+): WindowsListeningPidsResult {
   const result = readWindowsListeningPidsResultSync(port);
   if (!result.ok) {
     return result;
   }
-  return filterVerifiedWindowsGatewayPidsResult(result.pids, (pid) =>
-    readWindowsProcessArgsResultSync(pid),
+  return filterVerifiedWindowsGatewayPidsResult(
+    result.pids,
+    (pid) => readWindowsProcessArgsResultSync(pid),
+    protectedPid,
   );
 }
 
-/**
- * Find PIDs of gateway processes listening on the given port using synchronous lsof.
- * Returns only PIDs that belong to openclaw gateway processes (not the current process).
- */
-export function findGatewayPidsOnPortSync(
+function findGatewayPidsOnPortWithProtectedPidSync(
   port: number,
-  spawnTimeoutMs = SPAWN_TIMEOUT_MS,
+  spawnTimeoutMs: number,
+  protectedPid?: number,
 ): number[] {
   if (process.platform === "win32") {
     // Use the shared Windows port inspection (PowerShell / netstat) with
     // command-line verification to find only openclaw gateway processes.
-    return findVerifiedWindowsGatewayPidsOnPortSync(port);
+    return findVerifiedWindowsGatewayPidsOnPortSync(port, protectedPid);
   }
   const lsof = resolveLsofCommandSync();
   const res = spawnSync(lsof, ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-Fpc"], {
@@ -368,7 +384,18 @@ export function findGatewayPidsOnPortSync(
     );
     return [];
   }
-  return parsePidsFromLsofOutput(res.stdout, spawnTimeoutMs);
+  return parsePidsFromLsofOutput(res.stdout, spawnTimeoutMs, protectedPid);
+}
+
+/**
+ * Find PIDs of gateway processes listening on the given port using synchronous lsof.
+ * Returns only PIDs that belong to openclaw gateway processes (not the current process).
+ */
+export function findGatewayPidsOnPortSync(
+  port: number,
+  spawnTimeoutMs = SPAWN_TIMEOUT_MS,
+): number[] {
+  return findGatewayPidsOnPortWithProtectedPidSync(port, spawnTimeoutMs);
 }
 
 /**
@@ -586,23 +613,31 @@ function waitForPortFreeSync(port: number): void {
  *
  * Called before service restart commands to prevent port conflicts.
  */
-export function cleanStaleGatewayProcessesSync(portOverride?: number): number[] {
+type CleanStaleGatewayProcessesOptions = {
+  protectedPid?: number;
+};
+
+export function cleanStaleGatewayProcessesSync(
+  portOverride?: number,
+  options?: CleanStaleGatewayProcessesOptions,
+): number[] {
   try {
     const port =
       typeof portOverride === "number" && Number.isFinite(portOverride) && portOverride > 0
         ? Math.floor(portOverride)
         : resolveGatewayPort(undefined, process.env);
+    const protectedPid = options?.protectedPid;
     const stalePids =
       process.platform === "win32"
         ? (() => {
-            const result = findVerifiedWindowsGatewayPidsOnPortResultSync(port);
+            const result = findVerifiedWindowsGatewayPidsOnPortResultSync(port, protectedPid);
             if (result.ok) {
               return result.pids;
             }
             waitForPortFreeSync(port);
             return [];
           })()
-        : findGatewayPidsOnPortSync(port);
+        : findGatewayPidsOnPortWithProtectedPidSync(port, SPAWN_TIMEOUT_MS, protectedPid);
     if (stalePids.length === 0) {
       return [];
     }
