@dxos/phoenix 0.1.58-main.4cbb52d → 0.1.58-main.4e2a73a

package/dist/types/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC"}

package/dist/types/src/phoenix.d.ts

@@ -0,0 +1,16 @@
+import { ProcessInfo, WatchDogParams } from './watchdog';
+/**
+ * Utils to start/stop detached process with errors and logs handling.
+ */
+export declare class Phoenix {
+    /**
+     * Starts detached watchdog process which starts and monitors selected command.
+     */
+    static start(params: WatchDogParams): Promise<ProcessInfo>;
+    /**
+     * Stops detached watchdog process by PID info written down in PID file.
+     */
+    static stop(pidFile: string, force?: boolean): Promise<void>;
+    static info(pidFile: string): ProcessInfo;
+}
+//# sourceMappingURL=phoenix.d.ts.map

package/dist/types/src/phoenix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phoenix.d.ts","sourceRoot":"","sources":["../../../src/phoenix.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEzD;;GAEG;AACH,qBAAa,OAAO;IAClB;;OAEG;WACU,KAAK,CAAC,MAAM,EAAE,cAAc;IAyCzC;;OAEG;WACU,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,UAAQ;IAwBhD,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW;CAG1C"}

package/dist/types/src/phoenix.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=phoenix.test.d.ts.map

package/dist/types/src/phoenix.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phoenix.test.d.ts","sourceRoot":"","sources":["../../../src/phoenix.test.ts"],"names":[],"mappings":""}

package/dist/types/src/utils.d.ts

@@ -1,4 +1,4 @@
-export declare const waitForLockAcquisition: (lockFile: string) => Promise<boolean>;
-export declare const waitForLockFileBeingFilledWithInfo: (lockFile: string) => Promise<boolean>;
-export declare const waitForLockRelease: (lockFile: string) => Promise<boolean>;
+export declare const waitForPidCreation: (pidFile: string) => Promise<boolean>;
+export declare const waitForPidDeletion: (pidFile: string) => Promise<boolean>;
+export declare const waitForPidFileBeingFilledWithInfo: (pidFile: string) => Promise<boolean>;
 //# sourceMappingURL=utils.d.ts.map

package/dist/types/src/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/utils.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,sBAAsB,aAAoB,MAAM,qBAMzD,CAAC;AAEL,eAAO,MAAM,kCAAkC,aAAoB,MAAM,qBAMrE,CAAC;AAEL,eAAO,MAAM,kBAAkB,aAAoB,MAAM,qBAMrD,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/utils.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,kBAAkB,YAAmB,MAAM,qBAKpD,CAAC;AAEL,eAAO,MAAM,kBAAkB,YAAmB,MAAM,qBAKpD,CAAC;AAEL,eAAO,MAAM,iCAAiC,YAAmB,MAAM,qBAMnE,CAAC"}

package/dist/types/src/watchdog.d.ts

@@ -1,55 +1,36 @@
 /// <reference types="node" />
-export type DaemonInfo = {
-    pid: number;
-    command: string;
-    args: string[];
-    cwd: string;
-    timestamp: number;
-};
 export type ProcessInfo = WatchDogParams & {
     pid?: number;
-    timestamp?: number;
+    started?: number;
     restarts?: number;
     running?: boolean;
 };
-export type Lock = {
-    lockFile: string;
-};
-export type Logs = {
+export type WatchDogParams = {
+    profile?: string;
+    pidFile: string;
     logFile: string;
     errFile: string;
-};
-export type ChildParams = {
-    uid: string;
     maxRestarts?: number | undefined;
     killTree?: boolean | undefined;
-    command?: string;
+    command: string;
     args?: string[] | undefined;
     env?: NodeJS.ProcessEnv | undefined;
     cwd?: string | undefined;
     shell?: boolean | undefined;
 };
-export type WatchDogParams = ChildParams & Lock & Logs;
 export declare class WatchDog {
     private readonly _params;
     private _lock?;
     private _child?;
     private _restarts;
-    private _processCtx?;
     constructor(_params: WatchDogParams);
     start(): Promise<void>;
-    /**
-     * Sends SIGINT to the child process and the tree it spawned (if `killTree` param is `true`).
-     */
-    stop(): Promise<void>;
     /**
      * Sends SIGKILL to the child process and the tree it spawned (if `killTree` param is `true`).
      */
     kill(): Promise<void>;
     restart(): Promise<void>;
     _killWithSignal(signal: number | NodeJS.Signals): Promise<void>;
-    private _acquireLock;
-    private _releaseLock;
     private _log;
     private _err;
 }

package/dist/types/src/watchdog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watchdog.d.ts","sourceRoot":"","sources":["../../../src/watchdog.ts"],"names":[],"mappings":";AAkBA,MAAM,MAAM,UAAU,GAAG;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,cAAc,GAAG;IACzC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG;IAIjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,GAAG,EAAE,MAAM,CAAC;IAKZ,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAM/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAM5B,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,GAAG,SAAS,CAAC;IACpC,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,IAAI,GAAG,IAAI,CAAC;AAEvD,qBAAa,QAAQ;IAMP,OAAO,CAAC,QAAQ,CAAC,OAAO;IALpC,OAAO,CAAC,KAAK,CAAC,CAAa;IAC3B,OAAO,CAAC,MAAM,CAAC,CAAiC;IAChD,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,WAAW,CAAC,CAAU;gBAED,OAAO,EAAE,cAAc;IAG9C,KAAK;IAmDX;;OAEG;IAEG,IAAI;IAUV;;OAEG;IAEG,IAAI;IAUJ,OAAO;IAWP,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO;YAuBvC,YAAY;YAQZ,YAAY;IAS1B,OAAO,CAAC,IAAI;IAOZ,OAAO,CAAC,IAAI;CAOb"}
+{"version":3,"file":"watchdog.d.ts","sourceRoot":"","sources":["../../../src/watchdog.ts"],"names":[],"mappings":";AAcA,MAAM,MAAM,WAAW,GAAG,cAAc,GAAG;IACzC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAKhB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAKhB,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAM/B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAM5B,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,GAAG,SAAS,CAAC;IACpC,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC7B,CAAC;AAEF,qBAAa,QAAQ;IAKP,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJpC,OAAO,CAAC,KAAK,CAAC,CAAa;IAC3B,OAAO,CAAC,MAAM,CAAC,CAAiC;IAChD,OAAO,CAAC,SAAS,CAAK;gBAEO,OAAO,EAAE,cAAc;IAG9C,KAAK;IAmCX;;OAEG;IAEG,IAAI;IAcJ,OAAO;IAWP,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO;IAMrD,OAAO,CAAC,IAAI;IAOZ,OAAO,CAAC,IAAI;CAOb"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/phoenix",
-  "version": "0.1.58-main.4cbb52d",
+  "version": "0.1.58-main.4e2a73a",
   "description": "Basic node daemon.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -13,20 +13,17 @@
     "src"
   ],
   "dependencies": {
-    "fs-extra": "^8.1.0",
     "pkg-up": "^3.1.0",
-    "ps-tree": "^1.2.0",
-    "@dxos/async": "0.1.58-main.4cbb52d",
-    "@dxos/context": "0.1.58-main.4cbb52d",
-    "@dxos/invariant": "0.1.58-main.4cbb52d",
-    "@dxos/keys": "0.1.58-main.4cbb52d",
-    "@dxos/lock-file": "0.1.58-main.4cbb52d",
-    "@dxos/log": "0.1.58-main.4cbb52d",
-    "@dxos/node-std": "0.1.58-main.4cbb52d",
-    "@dxos/util": "0.1.58-main.4cbb52d"
+    "@dxos/async": "0.1.58-main.4e2a73a",
+    "@dxos/context": "0.1.58-main.4e2a73a",
+    "@dxos/invariant": "0.1.58-main.4e2a73a",
+    "@dxos/keys": "0.1.58-main.4e2a73a",
+    "@dxos/lock-file": "0.1.58-main.4e2a73a",
+    "@dxos/log": "0.1.58-main.4e2a73a",
+    "@dxos/node-std": "0.1.58-main.4e2a73a",
+    "@dxos/util": "0.1.58-main.4e2a73a"
   },
   "devDependencies": {
-    "@types/fs-extra": "^9.0.4",
     "@types/node": "^18.11.9",
     "@types/ps-tree": "^1.1.2"
   },

package/src/defs.ts

@@ -4,4 +4,6 @@
 
 export const LOCK_TIMEOUT = 1_000;
 export const LOCK_CHECK_INTERVAL = 50;
-export const DAEMON_START_TIMEOUT = 10_000;
+export const WATCHDOG_START_TIMEOUT = 10_000;
+export const WATCHDOG_STOP_TIMEOUT = 1_000;
+export const WATCHDOG_CHECK_INTERVAL = 50;

package/src/index.ts

@@ -6,5 +6,5 @@
 // Copyright (C) 2010 Charlie Robbins & the Contributors
 //
 
-export * from './daemon-manager';
+export * from './phoenix';
 export * from './watchdog';

package/src/{daemon-manager.test.ts → phoenix.test.ts}

@@ -3,18 +3,16 @@
 //
 
 import { expect } from 'chai';
-import fse from 'fs-extra';
 import { spawn } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import waitForExpect from 'wait-for-expect';
 
 import { Trigger } from '@dxos/async';
-import { PublicKey } from '@dxos/keys';
 import { afterTest, describe, test } from '@dxos/test';
 
-import { DaemonManager } from './daemon-manager';
-import { TEST_DIR, neverEndingProcess } from './testing-utils';
+import { Phoenix } from './phoenix';
+import { TEST_DIR, clearFiles, neverEndingProcess } from './testing-utils';
 
 describe('DaemonManager', () => {
   test('kill process by pid', async () => {
@@ -30,21 +28,23 @@ describe('DaemonManager', () => {
   });
 
   // Fails on CI
-  test.skip('start/stop detached watchdog', async () => {
-    const uid = `test-${PublicKey.random().toHex()}`;
-    const root = join(TEST_DIR, uid);
-    afterTest(() => {
-      fse.removeSync(root);
-    });
+  test('start/stop detached watchdog', async () => {
+    const runId = Math.random().toString();
+    const pidFile = join(TEST_DIR, `pid-${runId}.pid`);
+    const logFile = join(TEST_DIR, `file-${runId}.log`);
+    const errFile = join(TEST_DIR, `err-${runId}.log`);
+    afterTest(() => clearFiles(pidFile, logFile, errFile));
 
     // Start
     {
-      const manager = new DaemonManager(root);
-      const params = await manager.start({
-        uid,
+      const params = await Phoenix.start({
+        profile: runId,
         command: 'node',
         args: ['-e', `(${neverEndingProcess.toString()})()`],
         maxRestarts: 0,
+        pidFile,
+        logFile,
+        errFile,
       });
 
       await waitForExpect(() => {
@@ -56,17 +56,13 @@ describe('DaemonManager', () => {
 
     // Stop
     {
-      const manager = new DaemonManager(root);
-      const info = await manager.list();
-      expect(info.length).to.equal(1);
-      expect(info[0].running).to.be.true;
-      expect(info[0].uid).to.equal(uid);
-      expect(await manager.isRunning(uid)).to.be.true;
+      const info = Phoenix.info(pidFile);
+      expect(info.profile).to.equal(runId);
 
-      const params = await manager.stop(uid);
+      await Phoenix.stop(pidFile);
 
       await waitForExpect(() => {
-        const logs = readFileSync(params.logFile, { encoding: 'utf-8' });
+        const logs = readFileSync(logFile, { encoding: 'utf-8' });
         expect(logs).to.contain('Stopped with exit code');
       }, 1000);
     }

package/src/phoenix.ts

@@ -0,0 +1,94 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { fork } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import pkgUp from 'pkg-up';
+
+import { invariant } from '@dxos/invariant';
+import { log } from '@dxos/log';
+
+import { waitForPidDeletion, waitForPidFileBeingFilledWithInfo } from './utils';
+import { ProcessInfo, WatchDogParams } from './watchdog';
+
+/**
+ * Utils to start/stop detached process with errors and logs handling.
+ */
+export class Phoenix {
+  /**
+   * Starts detached watchdog process which starts and monitors selected command.
+   */
+  static async start(params: WatchDogParams) {
+    {
+      // Clear stale pid file.
+      if (existsSync(params.pidFile)) {
+        await Phoenix.stop(params.pidFile);
+      }
+
+      await waitForPidDeletion(params.pidFile);
+    }
+
+    {
+      // Create log folders.
+      [params.logFile, params.errFile, params.pidFile].forEach((filename) => {
+        if (!existsSync(filename)) {
+          mkdirSync(dirname(filename), { recursive: true });
+          writeFileSync(filename, '', { encoding: 'utf-8' });
+        }
+      });
+    }
+
+    const watchdogPath = join(dirname(pkgUp.sync({ cwd: __dirname })!), 'bin', 'watchdog');
+
+    const watchDog = fork(watchdogPath, [JSON.stringify(params)], {
+      detached: true,
+      cwd: __dirname,
+    });
+
+    watchDog.on('exit', (code, signal) => {
+      if (code && code !== 0) {
+        log.error('Monitor died unexpectedly', { code, signal });
+      }
+    });
+
+    await waitForPidFileBeingFilledWithInfo(params.pidFile);
+
+    watchDog.disconnect();
+    watchDog.unref();
+
+    return Phoenix.info(params.pidFile);
+  }
+
+  /**
+   * Stops detached watchdog process by PID info written down in PID file.
+   */
+  static async stop(pidFile: string, force = false) {
+    if (!existsSync(pidFile)) {
+      throw new Error('PID file does not exist');
+    }
+    const fileContent = readFileSync(pidFile, { encoding: 'utf-8' });
+    if (!fileContent.includes('pid')) {
+      throw new Error('Invalid PID file content');
+    }
+
+    const { pid } = JSON.parse(fileContent);
+    const signal: NodeJS.Signals = force ? 'SIGKILL' : 'SIGINT';
+    try {
+      process.kill(pid, signal);
+    } catch (err) {
+      invariant(err instanceof Error, 'Invalid error type');
+      if (err.message.includes('ESRCH') || err.name.includes('ESRCH')) {
+        // Process is already dead.
+        unlinkSync(pidFile);
+      } else {
+        throw err;
+      }
+    }
+  }
+
+  static info(pidFile: string): ProcessInfo {
+    return JSON.parse(readFileSync(pidFile, { encoding: 'utf-8' }));
+  }
+}

package/src/utils.ts

@@ -2,33 +2,30 @@
 // Copyright 2023 DXOS.org
 //
 
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 
 import { waitForCondition } from '@dxos/async';
-import { LockFile } from '@dxos/lock-file';
 
-import { LOCK_CHECK_INTERVAL, LOCK_TIMEOUT } from './defs';
+import { WATCHDOG_CHECK_INTERVAL, WATCHDOG_START_TIMEOUT, WATCHDOG_STOP_TIMEOUT } from './defs';
 
-export const waitForLockAcquisition = async (lockFile: string) =>
+export const waitForPidCreation = async (pidFile: string) =>
   waitForCondition({
-    condition: async () => await LockFile.isLocked(lockFile),
-    timeout: LOCK_TIMEOUT,
-    interval: LOCK_CHECK_INTERVAL,
-    error: new Error('Lock file is not being acquired.'),
+    condition: () => existsSync(pidFile),
+    timeout: WATCHDOG_START_TIMEOUT,
+    interval: WATCHDOG_CHECK_INTERVAL,
   });
 
-export const waitForLockFileBeingFilledWithInfo = async (lockFile: string) =>
+export const waitForPidDeletion = async (pidFile: string) =>
   waitForCondition({
-    condition: () => readFileSync(lockFile, { encoding: 'utf-8' }).includes('pid'),
-    timeout: LOCK_TIMEOUT,
-    interval: LOCK_CHECK_INTERVAL,
-    error: new Error('Lock file is not being propagated with info.'),
+    condition: () => !existsSync(pidFile),
+    timeout: WATCHDOG_STOP_TIMEOUT,
+    interval: WATCHDOG_CHECK_INTERVAL,
   });
 
-export const waitForLockRelease = async (lockFile: string) =>
+export const waitForPidFileBeingFilledWithInfo = async (pidFile: string) =>
   waitForCondition({
-    condition: async () => !(await LockFile.isLocked(lockFile)),
-    timeout: LOCK_TIMEOUT,
-    interval: LOCK_CHECK_INTERVAL,
-    error: new Error('Lock file is not being released.'),
+    condition: () => readFileSync(pidFile, { encoding: 'utf-8' }).includes('pid'),
+    timeout: WATCHDOG_START_TIMEOUT,
+    interval: WATCHDOG_CHECK_INTERVAL,
+    error: new Error('Lock file is not being propagated with info.'),
   });

package/src/watchdog.test.ts

@@ -3,10 +3,9 @@
 //
 
 import { expect } from 'chai';
+import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 
-import { asyncTimeout } from '@dxos/async';
-import { LockFile } from '@dxos/lock-file';
 import { afterTest, describe, test } from '@dxos/test';
 
 import { TEST_DIR, clearFiles, neverEndingProcess } from './testing-utils';
@@ -15,26 +14,25 @@ import { WatchDog } from './watchdog';
 describe('WatchDog', () => {
   test('Start/stop process', async () => {
     const runId = Math.random();
-    const lockFile = join(TEST_DIR, `lock-${runId}.lock`);
+    const pidFile = join(TEST_DIR, `pid-${runId}.pid`);
     const logFile = join(TEST_DIR, `file-${runId}.log`);
     const errFile = join(TEST_DIR, `err-${runId}.log`);
-    afterTest(() => clearFiles(lockFile, logFile, errFile));
+    afterTest(() => clearFiles(pidFile, logFile, errFile));
 
     const watchDog = new WatchDog({
-      uid: 'test',
       command: 'node',
       args: ['-e', `(${neverEndingProcess.toString()})()`],
-      lockFile,
+      pidFile,
       logFile,
       errFile,
     });
 
-    expect(await asyncTimeout(LockFile.isLocked(lockFile), 1000)).to.be.false;
+    expect(existsSync(pidFile)).to.be.false;
     await watchDog.start();
 
-    expect(await asyncTimeout(LockFile.isLocked(lockFile), 1000)).to.be.true;
+    expect(existsSync(pidFile)).to.be.true;
 
-    await watchDog.stop();
-    expect(await asyncTimeout(LockFile.isLocked(lockFile), 1000)).to.be.false;
+    await watchDog.kill();
+    expect(existsSync(pidFile)).to.be.false;
   });
 });

package/src/watchdog.ts

@@ -3,48 +3,31 @@
 //
 
 import { ChildProcessWithoutNullStreams, spawn } from 'node:child_process';
-import { writeFileSync } from 'node:fs';
+import { existsSync, unlinkSync, writeFileSync } from 'node:fs';
 import { FileHandle } from 'node:fs/promises';
-import { promisify } from 'node:util';
-import psTree from 'ps-tree';
 
 import { synchronized } from '@dxos/async';
-import { Context } from '@dxos/context';
 import { invariant } from '@dxos/invariant';
-import { LockFile } from '@dxos/lock-file';
 import { log } from '@dxos/log';
 
-import { waitForLockAcquisition, waitForLockRelease } from './utils';
-
-export type DaemonInfo = {
-  pid: number;
-  command: string;
-  args: string[];
-  cwd: string;
-  timestamp: number;
-};
+import { waitForPidDeletion, waitForPidFileBeingFilledWithInfo } from './utils';
 
 export type ProcessInfo = WatchDogParams & {
   pid?: number;
-  timestamp?: number;
+  started?: number;
   restarts?: number;
   running?: boolean;
 };
 
-export type Lock = {
-  lockFile: string; // Path to lock file
-};
+export type WatchDogParams = {
+  profile?: string; // Human readable process identifier
+  pidFile: string; // Path to PID file
 
-export type Logs = {
   //
   // Log files and associated logging options for this instance
   //
   logFile: string; // Path to log output all logs
   errFile: string; // Path to log output from child stderr
-};
-
-export type ChildParams = {
-  uid: string; // Unique identifier for this instance
 
   //
   // Basic configuration options
@@ -56,7 +39,7 @@ export type ChildParams = {
   // Command to spawn as well as options and other vars
   // (env, cwd, etc) to pass along
   //
-  command?: string; // Binary to run (default: 'node')
+  command: string; // Binary to run (default: 'node')
   args?: string[] | undefined; // Additional arguments to pass to the script,
 
   //
@@ -68,35 +51,19 @@ export type ChildParams = {
   shell?: boolean | undefined;
 };
 
-export type WatchDogParams = ChildParams & Lock & Logs;
-
 export class WatchDog {
   private _lock?: FileHandle;
   private _child?: ChildProcessWithoutNullStreams;
   private _restarts = 0;
-  private _processCtx?: Context;
 
   constructor(private readonly _params: WatchDogParams) {}
 
   @synchronized
   async start() {
-    await this._acquireLock();
-    this._log('Lock acquired.');
     const { cwd, shell, env, command, args } = { cwd: process.cwd(), ...this._params };
-    invariant(command, 'Command is not defined.');
 
-    this._log(`Spawning process ${command} ${args?.join(' ')}`);
+    this._log(`Spawning process \`\`\`${command} ${args?.join(' ')}\`\`\``);
     this._child = spawn(command, args, { cwd, shell, env, stdio: 'pipe' });
-    this._processCtx = new Context();
-
-    const childInfo: ProcessInfo = {
-      pid: process.pid,
-      timestamp: Date.now(),
-      restarts: this._restarts,
-      ...this._params,
-    };
-
-    writeFileSync(this._params.lockFile, JSON.stringify(childInfo, undefined, 2), { encoding: 'utf-8' });
 
     this._child.stdout.on('data', (data: Uint8Array) => {
       this._log(String(data));
@@ -104,44 +71,27 @@ export class WatchDog {
     this._child.stderr.on('data', (data: Uint8Array) => {
       this._err(data);
     });
-
-    // Setup restart handler.
-    {
-      const restartHandler = async (code: number, signal: number | NodeJS.Signals) => {
-        if (code && code !== 0) {
-          this._err(`Died unexpectedly with exit code ${code} (signal: ${signal}).`);
-          await this.restart();
-        }
-      };
-
-      this._child.on('close', restartHandler);
-
-      // We should unsubscribe from the event when the process is killed by us to not try to restart it.
-      this._processCtx.onDispose(() => {
-        this._child!.off('close', restartHandler);
-      });
-    }
-
-    this._child.on('close', (code: number, signal: number | NodeJS.Signals) => {
+    this._child.on('close', async (code: number, signal: number | NodeJS.Signals) => {
+      if (code && code !== 0 && signal !== 'SIGINT' && signal !== 'SIGKILL') {
+        this._err(`Died unexpectedly with exit code ${code} (signal: ${signal}).`);
+        await this.restart();
+      }
       this._log(`Stopped with exit code ${code} (signal: ${signal}).`);
+      if (existsSync(this._params.pidFile)) {
+        unlinkSync(this._params.pidFile);
+      }
     });
 
-    invariant(this._child.pid, 'Child process has no pid.');
-    this._log(`Started with pid ${this._child.pid}.`);
-  }
-
-  /**
-   * Sends SIGINT to the child process and the tree it spawned (if `killTree` param is `true`).
-   */
-  @synchronized
-  async stop() {
-    if (!this._child) {
-      return;
-    }
+    const childInfo: ProcessInfo = {
+      pid: this._child.pid,
+      started: Date.now(),
+      restarts: this._restarts,
+      ...this._params,
+    };
 
-    await this._killWithSignal('SIGKILL');
+    writeFileSync(this._params.pidFile, JSON.stringify(childInfo, undefined, 2), { encoding: 'utf-8' });
 
-    await this._releaseLock();
+    await waitForPidFileBeingFilledWithInfo(this._params.pidFile);
   }
 
   /**
@@ -155,7 +105,11 @@ export class WatchDog {
 
     await this._killWithSignal('SIGKILL');
 
-    await this._releaseLock();
+    if (existsSync(this._params.pidFile)) {
+      unlinkSync(this._params.pidFile);
+    }
+
+    await waitForPidDeletion(this._params.pidFile);
   }
 
   async restart() {
@@ -170,45 +124,11 @@ export class WatchDog {
   }
 
   async _killWithSignal(signal: number | NodeJS.Signals) {
-    invariant(this._processCtx, 'Process context is not defined.');
-    await this._processCtx.dispose();
-
-    // Kill child process tree.
-    if (this._params.killTree) {
-      if (process.platform !== 'win32') {
-        invariant(this._child?.pid, 'Child process has no pid.');
-        const children = await promisify(psTree)(this._child.pid);
-        children
-          .map((p) => p.PID)
-          .forEach((tpid) => {
-            invariant(tpid, 'Process id is not defined.');
-            process.kill(Number(tpid), signal);
-          });
-      }
-    }
-
     invariant(this._child?.pid, 'Child process has no pid.');
     this._child.kill(signal);
     this._child = undefined;
   }
 
-  private async _acquireLock() {
-    if (await LockFile.isLocked(this._params.lockFile)) {
-      throw new Error('Lock file is already locked.');
-    }
-    this._lock = await LockFile.acquire(this._params.lockFile);
-    await waitForLockAcquisition(this._params.lockFile);
-  }
-
-  private async _releaseLock() {
-    invariant(this._lock, 'Lock is not defined.');
-
-    await LockFile.release(this._lock);
-    await waitForLockRelease(this._params.lockFile);
-
-    this._lock = undefined;
-  }
-
   private _log(message: string | Uint8Array) {
     writeFileSync(this._params.logFile, message + '\n', {
       flag: 'a+',