@vacbo/opencode-anthropic-fix 0.1.7 → 0.1.9

package/src/parent-pid-watcher.test.ts

@@ -8,212 +8,212 @@ const originalPlatformDescriptor = Object.getOwnPropertyDescriptor(process, "pla
 const originalPpidDescriptor = Object.getOwnPropertyDescriptor(process, "ppid");
 
 function restorePlatform(): void {
-  if (originalPlatformDescriptor) {
-    Object.defineProperty(process, "platform", originalPlatformDescriptor);
-  }
+    if (originalPlatformDescriptor) {
+        Object.defineProperty(process, "platform", originalPlatformDescriptor);
+    }
 }
 
 function setPlatform(platform: NodeJS.Platform): void {
-  Object.defineProperty(process, "platform", {
-    value: platform,
-    configurable: true,
-  });
+    Object.defineProperty(process, "platform", {
+        value: platform,
+        configurable: true,
+    });
 }
 
 function restoreParentPid(): void {
-  if (originalPpidDescriptor) {
-    Object.defineProperty(process, "ppid", originalPpidDescriptor);
-  }
+    if (originalPpidDescriptor) {
+        Object.defineProperty(process, "ppid", originalPpidDescriptor);
+    }
 }
 
 function setCurrentParentPid(ppid: number): void {
-  Object.defineProperty(process, "ppid", {
-    value: ppid,
-    configurable: true,
-  });
+    Object.defineProperty(process, "ppid", {
+        value: ppid,
+        configurable: true,
+    });
 }
 
 function makeProcessError(code: "EPERM" | "ESRCH"): NodeJS.ErrnoException {
-  const error = new Error(`process.kill failed with ${code}`) as NodeJS.ErrnoException;
-  error.code = code;
-  return error;
+    const error = new Error(`process.kill failed with ${code}`) as NodeJS.ErrnoException;
+    error.code = code;
+    return error;
 }
 
 describe("ParentPidWatcher", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    restorePlatform();
-    restoreParentPid();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.restoreAllMocks();
-    restorePlatform();
-    restoreParentPid();
-  });
-
-  it("starts polling parent PID every 5 seconds by default", () => {
-    const onParentGone = vi.fn();
-    const intervalSpy = vi.spyOn(globalThis, "setInterval");
-    const killSpy = vi.spyOn(process, "kill").mockImplementation(() => true);
-
-    const watcher = new ParentPidWatcher({
-      parentPid: 4242,
-      onParentGone,
+    beforeEach(() => {
+        vi.useFakeTimers();
+        restorePlatform();
+        restoreParentPid();
     });
 
-    watcher.start();
+    afterEach(() => {
+        vi.useRealTimers();
+        vi.restoreAllMocks();
+        restorePlatform();
+        restoreParentPid();
+    });
 
-    expect(intervalSpy).toHaveBeenCalledTimes(1);
-    expect(intervalSpy).toHaveBeenLastCalledWith(expect.any(Function), 5000);
+    it("starts polling parent PID every 5 seconds by default", () => {
+        const onParentGone = vi.fn();
+        const intervalSpy = vi.spyOn(globalThis, "setInterval");
+        const killSpy = vi.spyOn(process, "kill").mockImplementation(() => true);
 
-    vi.advanceTimersByTime(5000);
+        const watcher = new ParentPidWatcher({
+            parentPid: 4242,
+            onParentGone,
+        });
 
-    expect(killSpy).toHaveBeenCalledWith(4242, 0);
-    expect(onParentGone).not.toHaveBeenCalled();
-  });
+        watcher.start();
 
-  it("fires the callback when process.kill(parentPid, 0) reports ESRCH", () => {
-    const onParentGone = vi.fn();
+        expect(intervalSpy).toHaveBeenCalledTimes(1);
+        expect(intervalSpy).toHaveBeenLastCalledWith(expect.any(Function), 5000);
 
-    vi.spyOn(process, "kill").mockImplementation(() => {
-      throw makeProcessError("ESRCH");
-    });
+        vi.advanceTimersByTime(5000);
 
-    const watcher = new ParentPidWatcher({
-      parentPid: 4242,
-      onParentGone,
+        expect(killSpy).toHaveBeenCalledWith(4242, 0);
+        expect(onParentGone).not.toHaveBeenCalled();
     });
 
-    watcher.start();
-    vi.advanceTimersByTime(5000);
+    it("fires the callback when process.kill(parentPid, 0) reports ESRCH", () => {
+        const onParentGone = vi.fn();
 
-    expect(onParentGone).toHaveBeenCalledTimes(1);
-  });
+        vi.spyOn(process, "kill").mockImplementation(() => {
+            throw makeProcessError("ESRCH");
+        });
 
-  it("fires the callback when process.ppid changes away from the configured parent PID", () => {
-    const onParentGone = vi.fn();
-    setCurrentParentPid(4242);
+        const watcher = new ParentPidWatcher({
+            parentPid: 4242,
+            onParentGone,
+        });
 
-    vi.spyOn(process, "kill").mockImplementation(() => true);
+        watcher.start();
+        vi.advanceTimersByTime(5000);
 
-    const watcher = new ParentPidWatcher({
-      parentPid: 4242,
-      onParentGone,
+        expect(onParentGone).toHaveBeenCalledTimes(1);
     });
 
-    watcher.start();
-    setCurrentParentPid(9001);
-    vi.advanceTimersByTime(5000);
+    it("fires the callback when process.ppid changes away from the configured parent PID", () => {
+        const onParentGone = vi.fn();
+        setCurrentParentPid(4242);
 
-    expect(onParentGone).toHaveBeenCalledTimes(1);
-  });
+        vi.spyOn(process, "kill").mockImplementation(() => true);
 
-  it("stops polling after the callback fires", () => {
-    const onParentGone = vi.fn();
-    const clearIntervalSpy = vi.spyOn(globalThis, "clearInterval");
-    const killSpy = vi.spyOn(process, "kill").mockImplementation(() => {
-      throw makeProcessError("ESRCH");
+        const watcher = new ParentPidWatcher({
+            parentPid: 4242,
+            onParentGone,
+        });
+
+        watcher.start();
+        setCurrentParentPid(9001);
+        vi.advanceTimersByTime(5000);
+
+        expect(onParentGone).toHaveBeenCalledTimes(1);
     });
 
-    const watcher = new ParentPidWatcher({
-      parentPid: 4242,
-      onParentGone,
+    it("stops polling after the callback fires", () => {
+        const onParentGone = vi.fn();
+        const clearIntervalSpy = vi.spyOn(globalThis, "clearInterval");
+        const killSpy = vi.spyOn(process, "kill").mockImplementation(() => {
+            throw makeProcessError("ESRCH");
+        });
+
+        const watcher = new ParentPidWatcher({
+            parentPid: 4242,
+            onParentGone,
+        });
+
+        watcher.start();
+        vi.advanceTimersByTime(5000);
+        vi.advanceTimersByTime(20_000);
+
+        expect(onParentGone).toHaveBeenCalledTimes(1);
+        expect(killSpy).toHaveBeenCalledTimes(1);
+        expect(clearIntervalSpy).toHaveBeenCalledTimes(1);
     });
 
-    watcher.start();
-    vi.advanceTimersByTime(5000);
-    vi.advanceTimersByTime(20_000);
+    it("manual stop() halts polling", () => {
+        const onParentGone = vi.fn();
+        const clearIntervalSpy = vi.spyOn(globalThis, "clearInterval");
+        const killSpy = vi.spyOn(process, "kill").mockImplementation(() => true);
 
-    expect(onParentGone).toHaveBeenCalledTimes(1);
-    expect(killSpy).toHaveBeenCalledTimes(1);
-    expect(clearIntervalSpy).toHaveBeenCalledTimes(1);
-  });
+        const watcher = new ParentPidWatcher({
+            parentPid: 4242,
+            pollIntervalMs: 1000,
+            onParentGone,
+        });
 
-  it("manual stop() halts polling", () => {
-    const onParentGone = vi.fn();
-    const clearIntervalSpy = vi.spyOn(globalThis, "clearInterval");
-    const killSpy = vi.spyOn(process, "kill").mockImplementation(() => true);
+        watcher.start();
+        watcher.stop();
+        vi.advanceTimersByTime(10_000);
 
-    const watcher = new ParentPidWatcher({
-      parentPid: 4242,
-      pollIntervalMs: 1000,
-      onParentGone,
+        expect(killSpy).not.toHaveBeenCalled();
+        expect(onParentGone).not.toHaveBeenCalled();
+        expect(clearIntervalSpy).toHaveBeenCalledTimes(1);
     });
 
-    watcher.start();
-    watcher.stop();
-    vi.advanceTimersByTime(10_000);
+    it("does not start polling for invalid parent PIDs", () => {
+        const intervalSpy = vi.spyOn(globalThis, "setInterval");
+        const onParentGone = vi.fn();
 
-    expect(killSpy).not.toHaveBeenCalled();
-    expect(onParentGone).not.toHaveBeenCalled();
-    expect(clearIntervalSpy).toHaveBeenCalledTimes(1);
-  });
+        expect(() => new ParentPidWatcher({ parentPid: 0, onParentGone }).start()).toThrow(/parent pid/i);
+        expect(() => new ParentPidWatcher({ parentPid: -1, onParentGone }).start()).toThrow(/parent pid/i);
+        expect(() => new ParentPidWatcher({ parentPid: Number.NaN, onParentGone }).start()).toThrow(/parent pid/i);
+        expect(intervalSpy).not.toHaveBeenCalled();
+    });
 
-  it("does not start polling for invalid parent PIDs", () => {
-    const intervalSpy = vi.spyOn(globalThis, "setInterval");
-    const onParentGone = vi.fn();
+    it("treats EPERM as parent-still-alive on macOS", () => {
+        const onParentGone = vi.fn();
+        setPlatform("darwin");
 
-    expect(() => new ParentPidWatcher({ parentPid: 0, onParentGone }).start()).toThrow(/parent pid/i);
-    expect(() => new ParentPidWatcher({ parentPid: -1, onParentGone }).start()).toThrow(/parent pid/i);
-    expect(() => new ParentPidWatcher({ parentPid: Number.NaN, onParentGone }).start()).toThrow(/parent pid/i);
-    expect(intervalSpy).not.toHaveBeenCalled();
-  });
+        const killSpy = vi.spyOn(process, "kill").mockImplementation(() => {
+            throw makeProcessError("EPERM");
+        });
 
-  it("treats EPERM as parent-still-alive on macOS", () => {
-    const onParentGone = vi.fn();
-    setPlatform("darwin");
+        const watcher = new ParentPidWatcher({
+            parentPid: 4242,
+            onParentGone,
+        });
 
-    const killSpy = vi.spyOn(process, "kill").mockImplementation(() => {
-      throw makeProcessError("EPERM");
-    });
+        watcher.start();
+        vi.advanceTimersByTime(5000);
 
-    const watcher = new ParentPidWatcher({
-      parentPid: 4242,
-      onParentGone,
+        expect(killSpy).toHaveBeenCalledWith(4242, 0);
+        expect(onParentGone).not.toHaveBeenCalled();
     });
 
-    watcher.start();
-    vi.advanceTimersByTime(5000);
+    it("treats EPERM as parent-still-alive on Linux", () => {
+        const onParentGone = vi.fn();
+        setPlatform("linux");
 
-    expect(killSpy).toHaveBeenCalledWith(4242, 0);
-    expect(onParentGone).not.toHaveBeenCalled();
-  });
+        const killSpy = vi.spyOn(process, "kill").mockImplementation(() => {
+            throw makeProcessError("EPERM");
+        });
 
-  it("treats EPERM as parent-still-alive on Linux", () => {
-    const onParentGone = vi.fn();
-    setPlatform("linux");
+        const watcher = new ParentPidWatcher({
+            parentPid: 4242,
+            onParentGone,
+        });
 
-    const killSpy = vi.spyOn(process, "kill").mockImplementation(() => {
-      throw makeProcessError("EPERM");
-    });
+        watcher.start();
+        vi.advanceTimersByTime(5000);
 
-    const watcher = new ParentPidWatcher({
-      parentPid: 4242,
-      onParentGone,
+        expect(killSpy).toHaveBeenCalledWith(4242, 0);
+        expect(onParentGone).not.toHaveBeenCalled();
     });
 
-    watcher.start();
-    vi.advanceTimersByTime(5000);
-
-    expect(killSpy).toHaveBeenCalledWith(4242, 0);
-    expect(onParentGone).not.toHaveBeenCalled();
-  });
+    it("uses the same parent-death contract on Windows via watchParentAndExit", () => {
+        setPlatform("win32");
 
-  it("uses the same parent-death contract on Windows via watchParentAndExit", () => {
-    setPlatform("win32");
+        const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => undefined) as never);
+        vi.spyOn(process, "kill").mockImplementation(() => {
+            throw makeProcessError("ESRCH");
+        });
 
-    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => undefined) as never);
-    vi.spyOn(process, "kill").mockImplementation(() => {
-      throw makeProcessError("ESRCH");
-    });
-
-    const watcher = watchParentAndExit(4242, 7);
+        const watcher = watchParentAndExit(4242, 7);
 
-    watcher.start();
-    vi.advanceTimersByTime(5000);
+        watcher.start();
+        vi.advanceTimersByTime(5000);
 
-    expect(exitSpy).toHaveBeenCalledWith(7);
-  });
+        expect(exitSpy).toHaveBeenCalledWith(7);
+    });
 });

package/src/parent-pid-watcher.ts

@@ -2,98 +2,98 @@ const DEFAULT_POLL_INTERVAL_MS = 5_000;
 const DEFAULT_PARENT_EXIT_CODE = 1;
 
 export interface ParentPidWatcherOptions {
-  parentPid: number;
-  pollIntervalMs?: number;
-  onParentGone: () => void;
+    parentPid: number;
+    pollIntervalMs?: number;
+    onParentGone: () => void;
 }
 
 function assertValidParentPid(parentPid: number): void {
-  if (!Number.isInteger(parentPid) || parentPid <= 0) {
-    throw new Error("Parent PID must be a positive integer.");
-  }
+    if (!Number.isInteger(parentPid) || parentPid <= 0) {
+        throw new Error("Parent PID must be a positive integer.");
+    }
 }
 
 function assertValidPollInterval(pollIntervalMs: number): void {
-  if (!Number.isFinite(pollIntervalMs) || pollIntervalMs <= 0) {
-    throw new Error("Poll interval must be a positive number.");
-  }
+    if (!Number.isFinite(pollIntervalMs) || pollIntervalMs <= 0) {
+        throw new Error("Poll interval must be a positive number.");
+    }
 }
 
 function isParentAlive(parentPid: number): boolean {
-  try {
-    process.kill(parentPid, 0);
-    return true;
-  } catch (error) {
-    const code = (error as NodeJS.ErrnoException).code;
-    if (code === "ESRCH") {
-      return false;
+    try {
+        process.kill(parentPid, 0);
+        return true;
+    } catch (error) {
+        const code = (error as NodeJS.ErrnoException).code;
+        if (code === "ESRCH") {
+            return false;
+        }
+
+        if (code === "EPERM") {
+            return true;
+        }
+
+        return true;
     }
-
-    if (code === "EPERM") {
-      return true;
-    }
-
-    return true;
-  }
 }
 
 export class ParentPidWatcher {
-  private readonly parentPid: number;
-  private readonly pollIntervalMs: number;
-  private readonly onParentGone: () => void;
-
-  private interval: ReturnType<typeof setInterval> | null = null;
-  private shouldMonitorPpidDrift = false;
-
-  constructor(options: ParentPidWatcherOptions) {
-    this.parentPid = options.parentPid;
-    this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-    this.onParentGone = options.onParentGone;
-  }
-
-  start(): void {
-    if (this.interval) {
-      return;
+    private readonly parentPid: number;
+    private readonly pollIntervalMs: number;
+    private readonly onParentGone: () => void;
+
+    private interval: ReturnType<typeof setInterval> | null = null;
+    private shouldMonitorPpidDrift = false;
+
+    constructor(options: ParentPidWatcherOptions) {
+        this.parentPid = options.parentPid;
+        this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+        this.onParentGone = options.onParentGone;
     }
 
-    assertValidParentPid(this.parentPid);
-    assertValidPollInterval(this.pollIntervalMs);
+    start(): void {
+        if (this.interval) {
+            return;
+        }
 
-    this.shouldMonitorPpidDrift = process.ppid === this.parentPid;
+        assertValidParentPid(this.parentPid);
+        assertValidPollInterval(this.pollIntervalMs);
 
-    this.interval = setInterval(() => {
-      if (this.shouldMonitorPpidDrift && process.ppid !== this.parentPid) {
-        this.handleParentGone();
-        return;
-      }
+        this.shouldMonitorPpidDrift = process.ppid === this.parentPid;
 
-      if (!isParentAlive(this.parentPid)) {
-        this.handleParentGone();
-      }
-    }, this.pollIntervalMs);
-  }
+        this.interval = setInterval(() => {
+            if (this.shouldMonitorPpidDrift && process.ppid !== this.parentPid) {
+                this.handleParentGone();
+                return;
+            }
 
-  stop(): void {
-    if (!this.interval) {
-      return;
+            if (!isParentAlive(this.parentPid)) {
+                this.handleParentGone();
+            }
+        }, this.pollIntervalMs);
     }
 
-    clearInterval(this.interval);
-    this.interval = null;
-    this.shouldMonitorPpidDrift = false;
-  }
+    stop(): void {
+        if (!this.interval) {
+            return;
+        }
 
-  private handleParentGone(): void {
-    this.stop();
-    this.onParentGone();
-  }
+        clearInterval(this.interval);
+        this.interval = null;
+        this.shouldMonitorPpidDrift = false;
+    }
+
+    private handleParentGone(): void {
+        this.stop();
+        this.onParentGone();
+    }
 }
 
 export function watchParentAndExit(parentPid: number, exitCode = DEFAULT_PARENT_EXIT_CODE): ParentPidWatcher {
-  return new ParentPidWatcher({
-    parentPid,
-    onParentGone: () => {
-      process.exit(exitCode);
-    },
-  });
+    return new ParentPidWatcher({
+        parentPid,
+        onParentGone: () => {
+            process.exit(exitCode);
+        },
+    });
 }