@dxos/phoenix 0.1.58-main.0009f6a

package/LICENSE

@@ -0,0 +1,8 @@
+MIT License 
+Copyright (c) 2023 DXOS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/lib/node/index.cjs

@@ -0,0 +1,294 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/common/phoenix/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Phoenix: () => Phoenix,
+  WatchDog: () => WatchDog
+});
+module.exports = __toCommonJS(src_exports);
+
+// packages/common/phoenix/src/phoenix.ts
+var import_node_child_process = require("node:child_process");
+var import_node_fs2 = require("node:fs");
+var import_node_path = require("node:path");
+var import_pkg_up = __toESM(require("pkg-up"));
+var import_invariant = require("@dxos/invariant");
+var import_log = require("@dxos/log");
+
+// packages/common/phoenix/src/utils.ts
+var import_node_fs = require("node:fs");
+var import_async = require("@dxos/async");
+
+// packages/common/phoenix/src/defs.ts
+var WATCHDOG_START_TIMEOUT = 1e4;
+var WATCHDOG_STOP_TIMEOUT = 1e3;
+var WATCHDOG_CHECK_INTERVAL = 50;
+
+// packages/common/phoenix/src/utils.ts
+var waitForPidDeletion = async (pidFile) => (0, import_async.waitForCondition)({
+  condition: () => !(0, import_node_fs.existsSync)(pidFile),
+  timeout: WATCHDOG_STOP_TIMEOUT,
+  interval: WATCHDOG_CHECK_INTERVAL
+});
+var waitForPidFileBeingFilledWithInfo = async (pidFile) => (0, import_async.waitForCondition)({
+  condition: () => (0, import_node_fs.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.")
+});
+
+// packages/common/phoenix/src/phoenix.ts
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/common/phoenix/src/phoenix.ts";
+var Phoenix = class _Phoenix {
+  /**
+  * Starts detached watchdog process which starts and monitors selected command.
+  */
+  static async start(params) {
+    {
+      if ((0, import_node_fs2.existsSync)(params.pidFile)) {
+        await _Phoenix.stop(params.pidFile);
+      }
+      await waitForPidDeletion(params.pidFile);
+    }
+    {
+      [
+        params.logFile,
+        params.errFile,
+        params.pidFile
+      ].forEach((filename) => {
+        if (!(0, import_node_fs2.existsSync)(filename)) {
+          (0, import_node_fs2.mkdirSync)((0, import_node_path.dirname)(filename), {
+            recursive: true
+          });
+          (0, import_node_fs2.writeFileSync)(filename, "", {
+            encoding: "utf-8"
+          });
+        }
+      });
+    }
+    const watchdogPath = (0, import_node_path.join)((0, import_node_path.dirname)(import_pkg_up.default.sync({
+      cwd: __dirname
+    })), "bin", "watchdog");
+    const watchDog = (0, import_node_child_process.fork)(watchdogPath, [
+      JSON.stringify(params)
+    ], {
+      detached: true,
+      cwd: __dirname
+    });
+    watchDog.on("exit", (code, signal) => {
+      if (code && code !== 0) {
+        import_log.log.error("Monitor died unexpectedly", {
+          code,
+          signal
+        }, {
+          F: __dxlog_file,
+          L: 52,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    });
+    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, force = false) {
+    if (!(0, import_node_fs2.existsSync)(pidFile)) {
+      throw new Error("PID file does not exist");
+    }
+    const fileContent = (0, import_node_fs2.readFileSync)(pidFile, {
+      encoding: "utf-8"
+    });
+    if (!fileContent.includes("pid")) {
+      throw new Error("Invalid PID file content");
+    }
+    const { pid } = JSON.parse(fileContent);
+    const signal = force ? "SIGKILL" : "SIGINT";
+    try {
+      process.kill(pid, signal);
+    } catch (err) {
+      (0, import_invariant.invariant)(err instanceof Error, "Invalid error type", {
+        F: __dxlog_file,
+        L: 81,
+        S: this,
+        A: [
+          "err instanceof Error",
+          "'Invalid error type'"
+        ]
+      });
+      if (err.message.includes("ESRCH") || err.name.includes("ESRCH")) {
+        (0, import_node_fs2.unlinkSync)(pidFile);
+      } else {
+        throw err;
+      }
+    }
+  }
+  static info(pidFile) {
+    return JSON.parse((0, import_node_fs2.readFileSync)(pidFile, {
+      encoding: "utf-8"
+    }));
+  }
+};
+
+// packages/common/phoenix/src/watchdog.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_fs3 = require("node:fs");
+var import_async2 = require("@dxos/async");
+var import_invariant2 = require("@dxos/invariant");
+var import_log2 = require("@dxos/log");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/common/phoenix/src/watchdog.ts";
+var WatchDog = class {
+  constructor(_params) {
+    this._params = _params;
+    this._restarts = 0;
+  }
+  async start() {
+    const { cwd, shell, env, command, args } = {
+      cwd: process.cwd(),
+      ...this._params
+    };
+    this._log(`Spawning process \`\`\`${command} ${args?.join(" ")}\`\`\``);
+    this._child = (0, import_node_child_process2.spawn)(command, args, {
+      cwd,
+      shell,
+      env,
+      stdio: "pipe"
+    });
+    this._child.stdout.on("data", (data) => {
+      this._log(String(data));
+    });
+    this._child.stderr.on("data", (data) => {
+      this._err(data);
+    });
+    this._child.on("close", async (code, signal) => {
+      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 ((0, import_node_fs3.existsSync)(this._params.pidFile)) {
+        (0, import_node_fs3.unlinkSync)(this._params.pidFile);
+      }
+    });
+    const childInfo = {
+      pid: this._child.pid,
+      started: Date.now(),
+      restarts: this._restarts,
+      ...this._params
+    };
+    (0, import_node_fs3.writeFileSync)(this._params.pidFile, JSON.stringify(childInfo, void 0, 2), {
+      encoding: "utf-8"
+    });
+    await waitForPidFileBeingFilledWithInfo(this._params.pidFile);
+  }
+  /**
+  * Sends SIGKILL to the child process and the tree it spawned (if `killTree` param is `true`).
+  */
+  async kill() {
+    if (!this._child) {
+      return;
+    }
+    await this._killWithSignal("SIGKILL");
+    if ((0, import_node_fs3.existsSync)(this._params.pidFile)) {
+      (0, import_node_fs3.unlinkSync)(this._params.pidFile);
+    }
+    await waitForPidDeletion(this._params.pidFile);
+  }
+  async restart() {
+    await this.kill();
+    if (this._params.maxRestarts !== void 0 && this._restarts >= this._params.maxRestarts) {
+      this._err("Max restarts number is reached");
+    } else {
+      (0, import_log2.log)("Restarting...", void 0, {
+        F: __dxlog_file2,
+        L: 120,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this._restarts++;
+      await this.start();
+    }
+  }
+  async _killWithSignal(signal) {
+    (0, import_invariant2.invariant)(this._child?.pid, "Child process has no pid.", {
+      F: __dxlog_file2,
+      L: 127,
+      S: this,
+      A: [
+        "this._child?.pid",
+        "'Child process has no pid.'"
+      ]
+    });
+    this._child.kill(signal);
+    this._child = void 0;
+  }
+  _log(message) {
+    (0, import_node_fs3.writeFileSync)(this._params.logFile, message + "\n", {
+      flag: "a+",
+      encoding: "utf-8"
+    });
+  }
+  _err(message) {
+    this._log(message);
+    (0, import_node_fs3.writeFileSync)(this._params.errFile, message + "\n", {
+      flag: "a+",
+      encoding: "utf-8"
+    });
+  }
+};
+_ts_decorate([
+  import_async2.synchronized
+], WatchDog.prototype, "start", null);
+_ts_decorate([
+  import_async2.synchronized
+], WatchDog.prototype, "kill", null);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Phoenix,
+  WatchDog
+});
+//# sourceMappingURL=index.cjs.map

package/dist/lib/node/index.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/index.ts", "../../../src/phoenix.ts", "../../../src/utils.ts", "../../../src/defs.ts", "../../../src/watchdog.ts"],
+  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n// Inspired by https://github.com/foreversd/forever\n// Their copyright notice is included below.\n// Copyright (C) 2010 Charlie Robbins & the Contributors\n//\n\nexport * from './phoenix';\nexport * from './watchdog';\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport { fork } from 'node:child_process';\nimport { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';\nimport { dirname, join } from 'node:path';\nimport pkgUp from 'pkg-up';\n\nimport { invariant } from '@dxos/invariant';\nimport { log } from '@dxos/log';\n\nimport { waitForPidDeletion, waitForPidFileBeingFilledWithInfo } from './utils';\nimport { ProcessInfo, WatchDogParams } from './watchdog';\n\n/**\n * Utils to start/stop detached process with errors and logs handling.\n */\nexport class Phoenix {\n  /**\n   * Starts detached watchdog process which starts and monitors selected command.\n   */\n  static async start(params: WatchDogParams) {\n    {\n      // Clear stale pid file.\n      if (existsSync(params.pidFile)) {\n        await Phoenix.stop(params.pidFile);\n      }\n\n      await waitForPidDeletion(params.pidFile);\n    }\n\n    {\n      // Create log folders.\n      [params.logFile, params.errFile, params.pidFile].forEach((filename) => {\n        if (!existsSync(filename)) {\n          mkdirSync(dirname(filename), { recursive: true });\n          writeFileSync(filename, '', { encoding: 'utf-8' });\n        }\n      });\n    }\n\n    const watchdogPath = join(dirname(pkgUp.sync({ cwd: __dirname })!), 'bin', 'watchdog');\n\n    const watchDog = fork(watchdogPath, [JSON.stringify(params)], {\n      detached: true,\n      cwd: __dirname,\n    });\n\n    watchDog.on('exit', (code, signal) => {\n      if (code && code !== 0) {\n        log.error('Monitor died unexpectedly', { code, signal });\n      }\n    });\n\n    await waitForPidFileBeingFilledWithInfo(params.pidFile);\n\n    watchDog.disconnect();\n    watchDog.unref();\n\n    return Phoenix.info(params.pidFile);\n  }\n\n  /**\n   * Stops detached watchdog process by PID info written down in PID file.\n   */\n  static async stop(pidFile: string, force = false) {\n    if (!existsSync(pidFile)) {\n      throw new Error('PID file does not exist');\n    }\n    const fileContent = readFileSync(pidFile, { encoding: 'utf-8' });\n    if (!fileContent.includes('pid')) {\n      throw new Error('Invalid PID file content');\n    }\n\n    const { pid } = JSON.parse(fileContent);\n    const signal: NodeJS.Signals = force ? 'SIGKILL' : 'SIGINT';\n    try {\n      process.kill(pid, signal);\n    } catch (err) {\n      invariant(err instanceof Error, 'Invalid error type');\n      if (err.message.includes('ESRCH') || err.name.includes('ESRCH')) {\n        // Process is already dead.\n        unlinkSync(pidFile);\n      } else {\n        throw err;\n      }\n    }\n  }\n\n  static info(pidFile: string): ProcessInfo {\n    return JSON.parse(readFileSync(pidFile, { encoding: 'utf-8' }));\n  }\n}\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport { existsSync, readFileSync } from 'node:fs';\n\nimport { waitForCondition } from '@dxos/async';\n\nimport { WATCHDOG_CHECK_INTERVAL, WATCHDOG_START_TIMEOUT, WATCHDOG_STOP_TIMEOUT } from './defs';\n\nexport const waitForPidCreation = async (pidFile: string) =>\n  waitForCondition({\n    condition: () => existsSync(pidFile),\n    timeout: WATCHDOG_START_TIMEOUT,\n    interval: WATCHDOG_CHECK_INTERVAL,\n  });\n\nexport const waitForPidDeletion = async (pidFile: string) =>\n  waitForCondition({\n    condition: () => !existsSync(pidFile),\n    timeout: WATCHDOG_STOP_TIMEOUT,\n    interval: WATCHDOG_CHECK_INTERVAL,\n  });\n\nexport const waitForPidFileBeingFilledWithInfo = async (pidFile: string) =>\n  waitForCondition({\n    condition: () => readFileSync(pidFile, { encoding: 'utf-8' }).includes('pid'),\n    timeout: WATCHDOG_START_TIMEOUT,\n    interval: WATCHDOG_CHECK_INTERVAL,\n    error: new Error('Lock file is not being propagated with info.'),\n  });\n", "//\n// Copyright 2023 DXOS.org\n//\n\nexport const LOCK_TIMEOUT = 1_000;\nexport const LOCK_CHECK_INTERVAL = 50;\nexport const WATCHDOG_START_TIMEOUT = 10_000;\nexport const WATCHDOG_STOP_TIMEOUT = 1_000;\nexport const WATCHDOG_CHECK_INTERVAL = 50;\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport { ChildProcessWithoutNullStreams, spawn } from 'node:child_process';\nimport { existsSync, unlinkSync, writeFileSync } from 'node:fs';\nimport { FileHandle } from 'node:fs/promises';\n\nimport { synchronized } from '@dxos/async';\nimport { invariant } from '@dxos/invariant';\nimport { log } from '@dxos/log';\n\nimport { waitForPidDeletion, waitForPidFileBeingFilledWithInfo } from './utils';\n\nexport type ProcessInfo = WatchDogParams & {\n  pid?: number;\n  started?: number;\n  restarts?: number;\n  running?: boolean;\n};\n\nexport type WatchDogParams = {\n  profile?: string; // Human readable process identifier\n  pidFile: string; // Path to PID file\n\n  //\n  // Log files and associated logging options for this instance\n  //\n  logFile: string; // Path to log output all logs\n  errFile: string; // Path to log output from child stderr\n\n  //\n  // Basic configuration options\n  //\n  maxRestarts?: number | undefined; // Sets the maximum number of times a given script should run\n  killTree?: boolean | undefined; // Kills the entire child process tree on `exit`\n\n  //\n  // Command to spawn as well as options and other vars\n  // (env, cwd, etc) to pass along\n  //\n  command: string; // Binary to run (default: 'node')\n  args?: string[] | undefined; // Additional arguments to pass to the script,\n\n  //\n  // More specific options to pass along to `child_process.spawn` which\n  // will override anything passed to the `spawnWith` option\n  //\n  env?: NodeJS.ProcessEnv | undefined;\n  cwd?: string | undefined;\n  shell?: boolean | undefined;\n};\n\nexport class WatchDog {\n  private _lock?: FileHandle;\n  private _child?: ChildProcessWithoutNullStreams;\n  private _restarts = 0;\n\n  constructor(private readonly _params: WatchDogParams) {}\n\n  @synchronized\n  async start() {\n    const { cwd, shell, env, command, args } = { cwd: process.cwd(), ...this._params };\n\n    this._log(`Spawning process \\`\\`\\`${command} ${args?.join(' ')}\\`\\`\\``);\n    this._child = spawn(command, args, { cwd, shell, env, stdio: 'pipe' });\n\n    this._child.stdout.on('data', (data: Uint8Array) => {\n      this._log(String(data));\n    });\n    this._child.stderr.on('data', (data: Uint8Array) => {\n      this._err(data);\n    });\n    this._child.on('close', async (code: number, signal: number | NodeJS.Signals) => {\n      if (code && code !== 0 && signal !== 'SIGINT' && signal !== 'SIGKILL') {\n        this._err(`Died unexpectedly with exit code ${code} (signal: ${signal}).`);\n        await this.restart();\n      }\n      this._log(`Stopped with exit code ${code} (signal: ${signal}).`);\n      if (existsSync(this._params.pidFile)) {\n        unlinkSync(this._params.pidFile);\n      }\n    });\n\n    const childInfo: ProcessInfo = {\n      pid: this._child.pid,\n      started: Date.now(),\n      restarts: this._restarts,\n      ...this._params,\n    };\n\n    writeFileSync(this._params.pidFile, JSON.stringify(childInfo, undefined, 2), { encoding: 'utf-8' });\n\n    await waitForPidFileBeingFilledWithInfo(this._params.pidFile);\n  }\n\n  /**\n   * Sends SIGKILL to the child process and the tree it spawned (if `killTree` param is `true`).\n   */\n  @synchronized\n  async kill() {\n    if (!this._child) {\n      return;\n    }\n\n    await this._killWithSignal('SIGKILL');\n\n    if (existsSync(this._params.pidFile)) {\n      unlinkSync(this._params.pidFile);\n    }\n\n    await waitForPidDeletion(this._params.pidFile);\n  }\n\n  async restart() {\n    await this.kill();\n    if (this._params.maxRestarts !== undefined && this._restarts >= this._params.maxRestarts) {\n      this._err('Max restarts number is reached');\n    } else {\n      log('Restarting...');\n      this._restarts++;\n      await this.start();\n    }\n  }\n\n  async _killWithSignal(signal: number | NodeJS.Signals) {\n    invariant(this._child?.pid, 'Child process has no pid.');\n    this._child.kill(signal);\n    this._child = undefined;\n  }\n\n  private _log(message: string | Uint8Array) {\n    writeFileSync(this._params.logFile, message + '\\n', {\n      flag: 'a+',\n      encoding: 'utf-8',\n    });\n  }\n\n  private _err(message: string | Uint8Array) {\n    this._log(message);\n    writeFileSync(this._params.errFile, message + '\\n', {\n      flag: 'a+',\n      encoding: 'utf-8',\n    });\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["import_node_fs", "WATCHDOG_START_TIMEOUT", "WATCHDOG_STOP_TIMEOUT", "WATCHDOG_CHECK_INTERVAL", "waitForPidDeletion", "pidFile", "waitForCondition", "condition", "existsSync", "timeout", "WATCHDOG_STOP_TIMEOUT", "interval", "WATCHDOG_CHECK_INTERVAL", "waitForPidFileBeingFilledWithInfo", "readFileSync", "encoding", "includes", "WATCHDOG_START_TIMEOUT", "error", "Error", "Phoenix", "start", "params", "existsSync", "pidFile", "stop", "waitForPidDeletion", "logFile", "errFile", "forEach", "filename", "mkdirSync", "dirname", "recursive", "writeFileSync", "encoding", "watchdogPath", "join", "pkgUp", "sync", "cwd", "__dirname", "watchDog", "fork", "JSON", "stringify", "detached", "on", "code", "signal", "log", "error", "waitForPidFileBeingFilledWithInfo", "disconnect", "unref", "info", "force", "Error", "fileContent", "readFileSync", "includes", "pid", "parse", "process", "kill", "err", "invariant", "message", "name", "unlinkSync", "import_node_child_process", "import_node_fs", "import_async", "import_invariant", "import_log", "WatchDog", "constructor", "_params", "_restarts", "start", "cwd", "shell", "env", "command", "args", "process", "_log", "join", "_child", "spawn", "stdio", "stdout", "on", "data", "String", "stderr", "_err", "code", "signal", "restart", "existsSync", "pidFile", "unlinkSync", "childInfo", "pid", "started", "Date", "now", "restarts", "writeFileSync", "JSON", "stringify", "undefined", "encoding", "waitForPidFileBeingFilledWithInfo", "kill", "_killWithSignal", "waitForPidDeletion", "maxRestarts", "log", "invariant", "message", "logFile", "flag", "errFile", "synchronized"]
+}

package/dist/lib/node/meta.json

@@ -0,0 +1 @@
+{"inputs":{"packages/common/phoenix/src/defs.ts":{"bytes":1201,"imports":[],"format":"esm"},"packages/common/phoenix/src/utils.ts":{"bytes":3673,"imports":[{"path":"node:fs","kind":"import-statement","external":true},{"path":"@dxos/async","kind":"import-statement","external":true},{"path":"packages/common/phoenix/src/defs.ts","kind":"import-statement","original":"./defs"}],"format":"esm"},"packages/common/phoenix/src/phoenix.ts":{"bytes":10474,"imports":[{"path":"node:child_process","kind":"import-statement","external":true},{"path":"node:fs","kind":"import-statement","external":true},{"path":"node:path","kind":"import-statement","external":true},{"path":"pkg-up","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/log","kind":"import-statement","external":true},{"path":"packages/common/phoenix/src/utils.ts","kind":"import-statement","original":"./utils"}],"format":"esm"},"packages/common/phoenix/src/watchdog.ts":{"bytes":14340,"imports":[{"path":"node:child_process","kind":"import-statement","external":true},{"path":"node:fs","kind":"import-statement","external":true},{"path":"@dxos/async","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/log","kind":"import-statement","external":true},{"path":"packages/common/phoenix/src/utils.ts","kind":"import-statement","original":"./utils"}],"format":"esm"},"packages/common/phoenix/src/index.ts":{"bytes":987,"imports":[{"path":"packages/common/phoenix/src/phoenix.ts","kind":"import-statement","original":"./phoenix"},{"path":"packages/common/phoenix/src/watchdog.ts","kind":"import-statement","original":"./watchdog"}],"format":"esm"}},"outputs":{"packages/common/phoenix/dist/lib/node/index.cjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":14468},"packages/common/phoenix/dist/lib/node/index.cjs":{"imports":[{"path":"node:child_process","kind":"require-call","external":true},{"path":"node:fs","kind":"require-call","external":true},{"path":"node:path","kind":"require-call","external":true},{"path":"pkg-up","kind":"require-call","external":true},{"path":"@dxos/invariant","kind":"require-call","external":true},{"path":"@dxos/log","kind":"require-call","external":true},{"path":"node:fs","kind":"require-call","external":true},{"path":"@dxos/async","kind":"require-call","external":true},{"path":"node:child_process","kind":"require-call","external":true},{"path":"node:fs","kind":"require-call","external":true},{"path":"@dxos/async","kind":"require-call","external":true},{"path":"@dxos/invariant","kind":"require-call","external":true},{"path":"@dxos/log","kind":"require-call","external":true}],"exports":[],"entryPoint":"packages/common/phoenix/src/index.ts","inputs":{"packages/common/phoenix/src/index.ts":{"bytesInOutput":147},"packages/common/phoenix/src/phoenix.ts":{"bytesInOutput":3063},"packages/common/phoenix/src/utils.ts":{"bytesInOutput":646},"packages/common/phoenix/src/defs.ts":{"bytesInOutput":101},"packages/common/phoenix/src/watchdog.ts":{"bytesInOutput":3933}},"bytes":9727}}}

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

@@ -0,0 +1,6 @@
+export declare const LOCK_TIMEOUT = 1000;
+export declare const LOCK_CHECK_INTERVAL = 50;
+export declare const WATCHDOG_START_TIMEOUT = 10000;
+export declare const WATCHDOG_STOP_TIMEOUT = 1000;
+export declare const WATCHDOG_CHECK_INTERVAL = 50;
+//# sourceMappingURL=defs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"defs.d.ts","sourceRoot":"","sources":["../../../src/defs.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY,OAAQ,CAAC;AAClC,eAAO,MAAM,mBAAmB,KAAK,CAAC;AACtC,eAAO,MAAM,sBAAsB,QAAS,CAAC;AAC7C,eAAO,MAAM,qBAAqB,OAAQ,CAAC;AAC3C,eAAO,MAAM,uBAAuB,KAAK,CAAC"}

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

@@ -0,0 +1,3 @@
+export * from './phoenix';
+export * from './watchdog';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"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/testing-utils.d.ts

@@ -0,0 +1,4 @@
+export declare const TEST_DIR = "/tmp/dxos/testing/phoenix";
+export declare const neverEndingProcess: () => void;
+export declare const clearFiles: (...filenames: string[]) => void;
+//# sourceMappingURL=testing-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"testing-utils.d.ts","sourceRoot":"","sources":["../../../src/testing-utils.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,QAAQ,8BAA8B,CAAC;AAKpD,eAAO,MAAM,kBAAkB,YAG9B,CAAC;AAEF,eAAO,MAAM,UAAU,iBAAkB,MAAM,EAAE,SAMhD,CAAC"}

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+export type ProcessInfo = WatchDogParams & {
+    pid?: number;
+    started?: number;
+    restarts?: number;
+    running?: boolean;
+};
+export type WatchDogParams = {
+    profile?: string;
+    pidFile: string;
+    logFile: string;
+    errFile: string;
+    maxRestarts?: number | undefined;
+    killTree?: boolean | undefined;
+    command: string;
+    args?: string[] | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+    cwd?: string | undefined;
+    shell?: boolean | undefined;
+};
+export declare class WatchDog {
+    private readonly _params;
+    private _lock?;
+    private _child?;
+    private _restarts;
+    constructor(_params: WatchDogParams);
+    start(): 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 _log;
+    private _err;
+}
+//# sourceMappingURL=watchdog.d.ts.map

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

@@ -0,0 +1 @@
+{"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/dist/types/src/watchdog.test.d.ts

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

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

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

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@dxos/phoenix",
+  "version": "0.1.58-main.0009f6a",
+  "description": "Basic node daemon.",
+  "homepage": "https://dxos.org",
+  "bugs": "https://github.com/dxos/dxos/issues",
+  "license": "MIT",
+  "author": "DXOS.org",
+  "main": "dist/lib/node/index.cjs",
+  "types": "dist/types/src/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "pkg-up": "^3.1.0",
+    "@dxos/async": "0.1.58-main.0009f6a",
+    "@dxos/context": "0.1.58-main.0009f6a",
+    "@dxos/invariant": "0.1.58-main.0009f6a",
+    "@dxos/keys": "0.1.58-main.0009f6a",
+    "@dxos/lock-file": "0.1.58-main.0009f6a",
+    "@dxos/log": "0.1.58-main.0009f6a",
+    "@dxos/node-std": "0.1.58-main.0009f6a",
+    "@dxos/util": "0.1.58-main.0009f6a"
+  },
+  "devDependencies": {
+    "@types/node": "^18.11.9",
+    "@types/ps-tree": "^1.1.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/defs.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+export const LOCK_TIMEOUT = 1_000;
+export const LOCK_CHECK_INTERVAL = 50;
+export const WATCHDOG_START_TIMEOUT = 10_000;
+export const WATCHDOG_STOP_TIMEOUT = 1_000;
+export const WATCHDOG_CHECK_INTERVAL = 50;

package/src/index.ts

@@ -0,0 +1,10 @@
+//
+// Copyright 2023 DXOS.org
+//
+// Inspired by https://github.com/foreversd/forever
+// Their copyright notice is included below.
+// Copyright (C) 2010 Charlie Robbins & the Contributors
+//
+
+export * from './phoenix';
+export * from './watchdog';

package/src/phoenix.test.ts

@@ -0,0 +1,70 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { expect } from 'chai';
+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 { afterTest, describe, test } from '@dxos/test';
+
+import { Phoenix } from './phoenix';
+import { TEST_DIR, clearFiles, neverEndingProcess } from './testing-utils';
+
+describe('DaemonManager', () => {
+  test('kill process by pid', async () => {
+    const child = spawn('node', ['-e', `(${neverEndingProcess.toString()})()`]);
+    const trigger = new Trigger();
+    child.on('exit', () => {
+      trigger.wake();
+    });
+
+    process.kill(child.pid!, 'SIGKILL');
+
+    await trigger.wait({ timeout: 1_000 });
+  });
+
+  // Fails on CI
+  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 params = await Phoenix.start({
+        profile: runId,
+        command: 'node',
+        args: ['-e', `(${neverEndingProcess.toString()})()`],
+        maxRestarts: 0,
+        pidFile,
+        logFile,
+        errFile,
+      });
+
+      await waitForExpect(() => {
+        expect(existsSync(params.logFile)).to.be.true;
+        const logs = readFileSync(params.logFile, { encoding: 'utf-8' });
+        expect(logs).to.contain('neverEndingProcess started');
+      }, 1000);
+    }
+
+    // Stop
+    {
+      const info = Phoenix.info(pidFile);
+      expect(info.profile).to.equal(runId);
+
+      await Phoenix.stop(pidFile);
+
+      await waitForExpect(() => {
+        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/testing-utils.ts

@@ -0,0 +1,23 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { existsSync, mkdirSync, unlinkSync } from 'node:fs';
+
+export const TEST_DIR = '/tmp/dxos/testing/phoenix';
+if (!existsSync(TEST_DIR)) {
+  mkdirSync(TEST_DIR, { recursive: true });
+}
+
+export const neverEndingProcess = () => {
+  console.log('neverEndingProcess started');
+  setTimeout(() => {}, 1_000_000);
+};
+
+export const clearFiles = (...filenames: string[]) => {
+  filenames.forEach((filename) => {
+    if (existsSync(filename)) {
+      unlinkSync(filename);
+    }
+  });
+};

package/src/utils.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { existsSync, readFileSync } from 'node:fs';
+
+import { waitForCondition } from '@dxos/async';
+
+import { WATCHDOG_CHECK_INTERVAL, WATCHDOG_START_TIMEOUT, WATCHDOG_STOP_TIMEOUT } from './defs';
+
+export const waitForPidCreation = async (pidFile: string) =>
+  waitForCondition({
+    condition: () => existsSync(pidFile),
+    timeout: WATCHDOG_START_TIMEOUT,
+    interval: WATCHDOG_CHECK_INTERVAL,
+  });
+
+export const waitForPidDeletion = async (pidFile: string) =>
+  waitForCondition({
+    condition: () => !existsSync(pidFile),
+    timeout: WATCHDOG_STOP_TIMEOUT,
+    interval: WATCHDOG_CHECK_INTERVAL,
+  });
+
+export const waitForPidFileBeingFilledWithInfo = async (pidFile: string) =>
+  waitForCondition({
+    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

@@ -0,0 +1,38 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { expect } from 'chai';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { afterTest, describe, test } from '@dxos/test';
+
+import { TEST_DIR, clearFiles, neverEndingProcess } from './testing-utils';
+import { WatchDog } from './watchdog';
+
+describe('WatchDog', () => {
+  test('Start/stop process', async () => {
+    const runId = Math.random();
+    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));
+
+    const watchDog = new WatchDog({
+      command: 'node',
+      args: ['-e', `(${neverEndingProcess.toString()})()`],
+      pidFile,
+      logFile,
+      errFile,
+    });
+
+    expect(existsSync(pidFile)).to.be.false;
+    await watchDog.start();
+
+    expect(existsSync(pidFile)).to.be.true;
+
+    await watchDog.kill();
+    expect(existsSync(pidFile)).to.be.false;
+  });
+});

package/src/watchdog.ts

@@ -0,0 +1,146 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { ChildProcessWithoutNullStreams, spawn } from 'node:child_process';
+import { existsSync, unlinkSync, writeFileSync } from 'node:fs';
+import { FileHandle } from 'node:fs/promises';
+
+import { synchronized } from '@dxos/async';
+import { invariant } from '@dxos/invariant';
+import { log } from '@dxos/log';
+
+import { waitForPidDeletion, waitForPidFileBeingFilledWithInfo } from './utils';
+
+export type ProcessInfo = WatchDogParams & {
+  pid?: number;
+  started?: number;
+  restarts?: number;
+  running?: boolean;
+};
+
+export type WatchDogParams = {
+  profile?: string; // Human readable process identifier
+  pidFile: string; // Path to PID file
+
+  //
+  // 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
+
+  //
+  // Basic configuration options
+  //
+  maxRestarts?: number | undefined; // Sets the maximum number of times a given script should run
+  killTree?: boolean | undefined; // Kills the entire child process tree on `exit`
+
+  //
+  // Command to spawn as well as options and other vars
+  // (env, cwd, etc) to pass along
+  //
+  command: string; // Binary to run (default: 'node')
+  args?: string[] | undefined; // Additional arguments to pass to the script,
+
+  //
+  // More specific options to pass along to `child_process.spawn` which
+  // will override anything passed to the `spawnWith` option
+  //
+  env?: NodeJS.ProcessEnv | undefined;
+  cwd?: string | undefined;
+  shell?: boolean | undefined;
+};
+
+export class WatchDog {
+  private _lock?: FileHandle;
+  private _child?: ChildProcessWithoutNullStreams;
+  private _restarts = 0;
+
+  constructor(private readonly _params: WatchDogParams) {}
+
+  @synchronized
+  async start() {
+    const { cwd, shell, env, command, args } = { cwd: process.cwd(), ...this._params };
+
+    this._log(`Spawning process \`\`\`${command} ${args?.join(' ')}\`\`\``);
+    this._child = spawn(command, args, { cwd, shell, env, stdio: 'pipe' });
+
+    this._child.stdout.on('data', (data: Uint8Array) => {
+      this._log(String(data));
+    });
+    this._child.stderr.on('data', (data: Uint8Array) => {
+      this._err(data);
+    });
+    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);
+      }
+    });
+
+    const childInfo: ProcessInfo = {
+      pid: this._child.pid,
+      started: Date.now(),
+      restarts: this._restarts,
+      ...this._params,
+    };
+
+    writeFileSync(this._params.pidFile, JSON.stringify(childInfo, undefined, 2), { encoding: 'utf-8' });
+
+    await waitForPidFileBeingFilledWithInfo(this._params.pidFile);
+  }
+
+  /**
+   * Sends SIGKILL to the child process and the tree it spawned (if `killTree` param is `true`).
+   */
+  @synchronized
+  async kill() {
+    if (!this._child) {
+      return;
+    }
+
+    await this._killWithSignal('SIGKILL');
+
+    if (existsSync(this._params.pidFile)) {
+      unlinkSync(this._params.pidFile);
+    }
+
+    await waitForPidDeletion(this._params.pidFile);
+  }
+
+  async restart() {
+    await this.kill();
+    if (this._params.maxRestarts !== undefined && this._restarts >= this._params.maxRestarts) {
+      this._err('Max restarts number is reached');
+    } else {
+      log('Restarting...');
+      this._restarts++;
+      await this.start();
+    }
+  }
+
+  async _killWithSignal(signal: number | NodeJS.Signals) {
+    invariant(this._child?.pid, 'Child process has no pid.');
+    this._child.kill(signal);
+    this._child = undefined;
+  }
+
+  private _log(message: string | Uint8Array) {
+    writeFileSync(this._params.logFile, message + '\n', {
+      flag: 'a+',
+      encoding: 'utf-8',
+    });
+  }
+
+  private _err(message: string | Uint8Array) {
+    this._log(message);
+    writeFileSync(this._params.errFile, message + '\n', {
+      flag: 'a+',
+      encoding: 'utf-8',
+    });
+  }
+}