@dxos/phoenix 0.1.58-main.0e9c99e

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,444 @@
+"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, {
+  DaemonManager: () => DaemonManager,
+  WatchDog: () => WatchDog
+});
+module.exports = __toCommonJS(src_exports);
+
+// packages/common/phoenix/src/daemon-manager.ts
+var import_node_child_process = require("node:child_process");
+var import_node_fs2 = require("node:fs");
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+var import_pkg_up = __toESM(require("pkg-up"));
+var import_invariant = require("@dxos/invariant");
+var import_lock_file2 = require("@dxos/lock-file");
+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");
+var import_lock_file = require("@dxos/lock-file");
+
+// packages/common/phoenix/src/defs.ts
+var LOCK_TIMEOUT = 1e3;
+var LOCK_CHECK_INTERVAL = 50;
+
+// packages/common/phoenix/src/utils.ts
+var waitForLockAcquisition = async (lockFile) => (0, import_async.waitForCondition)({
+  condition: async () => await import_lock_file.LockFile.isLocked(lockFile),
+  timeout: LOCK_TIMEOUT,
+  interval: LOCK_CHECK_INTERVAL,
+  error: new Error("Lock file is not being acquired.")
+});
+var waitForLockFileBeingFilledWithInfo = async (lockFile) => (0, import_async.waitForCondition)({
+  condition: () => (0, import_node_fs.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.")
+});
+var waitForLockRelease = async (lockFile) => (0, import_async.waitForCondition)({
+  condition: async () => !await import_lock_file.LockFile.isLocked(lockFile),
+  timeout: LOCK_TIMEOUT,
+  interval: LOCK_CHECK_INTERVAL,
+  error: new Error("Lock file is not being released.")
+});
+
+// packages/common/phoenix/src/daemon-manager.ts
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/common/phoenix/src/daemon-manager.ts";
+var LOCK_FILE_NAME = "lockfile";
+var DaemonManager = class {
+  constructor(_rootPath) {
+    this._rootPath = _rootPath;
+    if (!(0, import_node_fs2.existsSync)((0, import_node_path.join)(_rootPath, "profile"))) {
+      (0, import_node_fs2.mkdirSync)((0, import_node_path.join)(_rootPath, "profile"), {
+        recursive: true
+      });
+    }
+  }
+  _getConfigFiles(uid) {
+    const defaultConfigDir = (0, import_node_path.join)(this._rootPath, "profile", uid);
+    if (!(0, import_node_fs2.existsSync)(defaultConfigDir)) {
+      (0, import_node_fs2.mkdirSync)(defaultConfigDir, {
+        recursive: true
+      });
+    }
+    return {
+      lockFile: (0, import_node_path.join)(defaultConfigDir, LOCK_FILE_NAME),
+      logFile: (0, import_node_path.join)(defaultConfigDir, "file.log"),
+      errFile: (0, import_node_path.join)(defaultConfigDir, "err.log")
+    };
+  }
+  async start(params) {
+    (0, import_invariant.invariant)(params.command, "command is required", {
+      F: __dxlog_file,
+      L: 46,
+      S: this,
+      A: [
+        "params.command",
+        "'command is required'"
+      ]
+    });
+    const watchDogParams = {
+      ...this._getConfigFiles(params.uid),
+      ...params
+    };
+    {
+      (0, import_node_fs2.mkdirSync)((0, import_node_path.dirname)(watchDogParams.logFile), {
+        recursive: true
+      });
+      (0, import_node_fs2.mkdirSync)((0, import_node_path.dirname)(watchDogParams.errFile), {
+        recursive: true
+      });
+    }
+    {
+      if (await import_lock_file2.LockFile.isLocked(watchDogParams.lockFile)) {
+        throw new Error("Lock file is already locked.");
+      }
+      (0, import_node_fs2.unlinkSync)(watchDogParams.lockFile);
+    }
+    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(watchDogParams)
+    ], {
+      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: 75,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    });
+    await waitForLockAcquisition(watchDogParams.lockFile);
+    await waitForLockFileBeingFilledWithInfo(watchDogParams.lockFile);
+    watchDog.disconnect();
+    watchDog.unref();
+    return this.getInfo(params.uid);
+  }
+  async stop(uid, force) {
+    const lockFile = this._getConfigFiles(uid).lockFile;
+    const processInfo = JSON.parse((0, import_node_fs2.readFileSync)(lockFile, {
+      encoding: "utf-8"
+    }));
+    try {
+      if (force) {
+        process.kill(processInfo.pid, "SIGKILL");
+      } else {
+        process.kill(processInfo.pid, "SIGINT");
+      }
+    } catch (err) {
+      (0, import_invariant.invariant)(err instanceof Error, "Invalid error type.", {
+        F: __dxlog_file,
+        L: 98,
+        S: this,
+        A: [
+          "err instanceof Error",
+          "'Invalid error type.'"
+        ]
+      });
+      if (!err.name.includes("ESRCH") && !err.message.includes("ESRCH")) {
+        throw err;
+      }
+    }
+    await waitForLockRelease(lockFile);
+    return this.getInfo(uid);
+  }
+  async list() {
+    const uids = (await (0, import_promises.readdir)((0, import_node_path.join)(this._rootPath, "profile"))).filter((uid) => !uid.startsWith("."));
+    return Promise.all(uids.map(async (uid) => {
+      return this.getInfo(uid);
+    }));
+  }
+  async getInfo(uid) {
+    const files = this._getConfigFiles(uid);
+    let info = {
+      running: await import_lock_file2.LockFile.isLocked(files.lockFile),
+      uid,
+      ...files
+    };
+    if ((0, import_node_fs2.existsSync)(files.lockFile)) {
+      try {
+        info = {
+          ...info,
+          ...JSON.parse((0, import_node_fs2.readFileSync)(files.lockFile, {
+            encoding: "utf-8"
+          }))
+        };
+      } catch (err) {
+      }
+    }
+    return info;
+  }
+  async isRunning(uid) {
+    const lockFile = this._getConfigFiles(uid).lockFile;
+    return import_lock_file2.LockFile.isLocked(lockFile);
+  }
+};
+
+// packages/common/phoenix/src/watchdog.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_fs3 = require("node:fs");
+var import_node_util = require("node:util");
+var import_ps_tree = __toESM(require("ps-tree"));
+var import_async2 = require("@dxos/async");
+var import_context = require("@dxos/context");
+var import_invariant2 = require("@dxos/invariant");
+var import_lock_file3 = require("@dxos/lock-file");
+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() {
+    await this._acquireLock();
+    this._log("Lock acquired.");
+    const { cwd, shell, env, command, args } = {
+      cwd: process.cwd(),
+      ...this._params
+    };
+    (0, import_invariant2.invariant)(command, "Command is not defined.", {
+      F: __dxlog_file2,
+      L: 86,
+      S: this,
+      A: [
+        "command",
+        "'Command is not defined.'"
+      ]
+    });
+    this._log(`Spawning process ${command} ${args?.join(" ")}`);
+    this._child = (0, import_node_child_process2.spawn)(command, args, {
+      cwd,
+      shell,
+      env,
+      stdio: "pipe"
+    });
+    this._processCtx = new import_context.Context();
+    const childInfo = {
+      pid: process.pid,
+      timestamp: Date.now(),
+      restarts: this._restarts,
+      ...this._params
+    };
+    (0, import_node_fs3.writeFileSync)(this._params.lockFile, JSON.stringify(childInfo, void 0, 2), {
+      encoding: "utf-8"
+    });
+    this._child.stdout.on("data", (data) => {
+      this._log(String(data));
+    });
+    this._child.stderr.on("data", (data) => {
+      this._err(data);
+    });
+    {
+      const restartHandler = async (code, signal) => {
+        if (code && code !== 0) {
+          this._err(`Died unexpectedly with exit code ${code} (signal: ${signal}).`);
+          await this.restart();
+        }
+      };
+      this._child.on("close", restartHandler);
+      this._processCtx.onDispose(() => {
+        this._child.off("close", restartHandler);
+      });
+    }
+    this._child.on("close", (code, signal) => {
+      this._log(`Stopped with exit code ${code} (signal: ${signal}).`);
+    });
+    (0, import_invariant2.invariant)(this._child.pid, "Child process has no pid.", {
+      F: __dxlog_file2,
+      L: 129,
+      S: this,
+      A: [
+        "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`).
+  */
+  async stop() {
+    if (!this._child) {
+      return;
+    }
+    await this._killWithSignal("SIGKILL");
+    await this._releaseLock();
+  }
+  /**
+  * 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");
+    await this._releaseLock();
+  }
+  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: 166,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this._restarts++;
+      await this.start();
+    }
+  }
+  async _killWithSignal(signal) {
+    (0, import_invariant2.invariant)(this._processCtx, "Process context is not defined.", {
+      F: __dxlog_file2,
+      L: 173,
+      S: this,
+      A: [
+        "this._processCtx",
+        "'Process context is not defined.'"
+      ]
+    });
+    await this._processCtx.dispose();
+    if (this._params.killTree) {
+      if (process.platform !== "win32") {
+        (0, import_invariant2.invariant)(this._child?.pid, "Child process has no pid.", {
+          F: __dxlog_file2,
+          L: 179,
+          S: this,
+          A: [
+            "this._child?.pid",
+            "'Child process has no pid.'"
+          ]
+        });
+        const children = await (0, import_node_util.promisify)(import_ps_tree.default)(this._child.pid);
+        children.map((p) => p.PID).forEach((tpid) => {
+          (0, import_invariant2.invariant)(tpid, "Process id is not defined.", {
+            F: __dxlog_file2,
+            L: 184,
+            S: this,
+            A: [
+              "tpid",
+              "'Process id is not defined.'"
+            ]
+          });
+          process.kill(Number(tpid), signal);
+        });
+      }
+    }
+    (0, import_invariant2.invariant)(this._child?.pid, "Child process has no pid.", {
+      F: __dxlog_file2,
+      L: 190,
+      S: this,
+      A: [
+        "this._child?.pid",
+        "'Child process has no pid.'"
+      ]
+    });
+    this._child.kill(signal);
+    this._child = void 0;
+  }
+  async _acquireLock() {
+    if (await import_lock_file3.LockFile.isLocked(this._params.lockFile)) {
+      throw new Error("Lock file is already locked.");
+    }
+    this._lock = await import_lock_file3.LockFile.acquire(this._params.lockFile);
+    await waitForLockAcquisition(this._params.lockFile);
+  }
+  async _releaseLock() {
+    (0, import_invariant2.invariant)(this._lock, "Lock is not defined.", {
+      F: __dxlog_file2,
+      L: 204,
+      S: this,
+      A: [
+        "this._lock",
+        "'Lock is not defined.'"
+      ]
+    });
+    await import_lock_file3.LockFile.release(this._lock);
+    await waitForLockRelease(this._params.lockFile);
+    this._lock = 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, "stop", null);
+_ts_decorate([
+  import_async2.synchronized
+], WatchDog.prototype, "kill", null);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DaemonManager,
+  WatchDog
+});
+//# sourceMappingURL=index.cjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/index.ts", "../../../src/daemon-manager.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 './daemon-manager';\nexport * from './watchdog';\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport { fork } from 'node:child_process';\nimport { existsSync, mkdirSync, readFileSync, unlinkSync } from 'node:fs';\nimport { readdir } from 'node:fs/promises';\nimport { dirname, join } from 'node:path';\nimport pkgUp from 'pkg-up';\n\nimport { invariant } from '@dxos/invariant';\nimport { LockFile } from '@dxos/lock-file';\nimport { log } from '@dxos/log';\n\nimport { waitForLockAcquisition, waitForLockFileBeingFilledWithInfo, waitForLockRelease } from './utils';\nimport { ChildParams, Logs, Lock, ProcessInfo, WatchDogParams } from './watchdog';\n\nconst LOCK_FILE_NAME = 'lockfile';\n\n/**\n * Params to start a daemon.\n * User have no control over the lock file.\n */\nexport type StartParams = ChildParams & Partial<Logs>;\n\nexport class DaemonManager {\n  constructor(private readonly _rootPath: string) {\n    if (!existsSync(join(_rootPath, 'profile'))) {\n      mkdirSync(join(_rootPath, 'profile'), { recursive: true });\n    }\n  }\n\n  private _getConfigFiles(uid: string): Logs & Lock {\n    const defaultConfigDir = join(this._rootPath, 'profile', uid);\n    if (!existsSync(defaultConfigDir)) {\n      mkdirSync(defaultConfigDir, { recursive: true });\n    }\n    return {\n      lockFile: join(defaultConfigDir, LOCK_FILE_NAME),\n      logFile: join(defaultConfigDir, 'file.log'),\n      errFile: join(defaultConfigDir, 'err.log'),\n    };\n  }\n\n  async start(params: StartParams) {\n    invariant(params.command, 'command is required');\n    const watchDogParams: WatchDogParams = {\n      ...this._getConfigFiles(params.uid),\n      ...params,\n    };\n\n    {\n      // Create log folders.\n      mkdirSync(dirname(watchDogParams.logFile), { recursive: true });\n      mkdirSync(dirname(watchDogParams.errFile), { recursive: true });\n    }\n\n    {\n      // Clear stale lock file if process is not running.\n      if (await LockFile.isLocked(watchDogParams.lockFile)) {\n        throw new Error('Lock file is already locked.');\n      }\n      unlinkSync(watchDogParams.lockFile);\n    }\n\n    const watchdogPath = join(dirname(pkgUp.sync({ cwd: __dirname })!), 'bin', 'watchdog');\n\n    const watchDog = fork(watchdogPath, [JSON.stringify(watchDogParams)], {\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 waitForLockAcquisition(watchDogParams.lockFile);\n    await waitForLockFileBeingFilledWithInfo(watchDogParams.lockFile);\n\n    watchDog.disconnect();\n    watchDog.unref();\n\n    return this.getInfo(params.uid);\n  }\n\n  async stop(uid: string, force?: boolean) {\n    const lockFile = this._getConfigFiles(uid).lockFile;\n    const processInfo = JSON.parse(readFileSync(lockFile, { encoding: 'utf-8' }));\n    try {\n      if (force) {\n        process.kill(processInfo.pid, 'SIGKILL');\n      } else {\n        process.kill(processInfo.pid, 'SIGINT');\n      }\n    } catch (err) {\n      invariant(err instanceof Error, 'Invalid error type.');\n      if (!err.name.includes('ESRCH') && !err.message.includes('ESRCH')) {\n        throw err;\n      }\n    }\n    await waitForLockRelease(lockFile);\n\n    return this.getInfo(uid);\n  }\n\n  async list(): Promise<ProcessInfo[]> {\n    const uids = (await readdir(join(this._rootPath, 'profile'))).filter((uid) => !uid.startsWith('.'));\n\n    return Promise.all(\n      uids.map(async (uid) => {\n        return this.getInfo(uid);\n      }),\n    );\n  }\n\n  async getInfo(uid: string): Promise<ProcessInfo> {\n    const files = this._getConfigFiles(uid);\n\n    let info: ProcessInfo = { running: await LockFile.isLocked(files.lockFile), uid, ...files };\n    if (existsSync(files.lockFile)) {\n      try {\n        info = {\n          ...info,\n          ...JSON.parse(readFileSync(files.lockFile, { encoding: 'utf-8' })),\n        };\n      } catch (err) {}\n    }\n\n    return info;\n  }\n\n  async isRunning(uid: string): Promise<boolean> {\n    const lockFile = this._getConfigFiles(uid).lockFile;\n    return LockFile.isLocked(lockFile);\n  }\n}\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport { readFileSync } from 'node:fs';\n\nimport { waitForCondition } from '@dxos/async';\nimport { LockFile } from '@dxos/lock-file';\n\nimport { LOCK_CHECK_INTERVAL, LOCK_TIMEOUT } from './defs';\n\nexport const waitForLockAcquisition = async (lockFile: string) =>\n  waitForCondition({\n    condition: async () => await LockFile.isLocked(lockFile),\n    timeout: LOCK_TIMEOUT,\n    interval: LOCK_CHECK_INTERVAL,\n    error: new Error('Lock file is not being acquired.'),\n  });\n\nexport const waitForLockFileBeingFilledWithInfo = async (lockFile: string) =>\n  waitForCondition({\n    condition: () => readFileSync(lockFile, { encoding: 'utf-8' }).includes('pid'),\n    timeout: LOCK_TIMEOUT,\n    interval: LOCK_CHECK_INTERVAL,\n    error: new Error('Lock file is not being propagated with info.'),\n  });\n\nexport const waitForLockRelease = async (lockFile: string) =>\n  waitForCondition({\n    condition: async () => !(await LockFile.isLocked(lockFile)),\n    timeout: LOCK_TIMEOUT,\n    interval: LOCK_CHECK_INTERVAL,\n    error: new Error('Lock file is not being released.'),\n  });\n", "//\n// Copyright 2023 DXOS.org\n//\n\nexport const LOCK_TIMEOUT = 1_000;\nexport const LOCK_CHECK_INTERVAL = 50;\nexport const DAEMON_START_TIMEOUT = 10_000;\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport { ChildProcessWithoutNullStreams, spawn } from 'node:child_process';\nimport { writeFileSync } from 'node:fs';\nimport { FileHandle } from 'node:fs/promises';\nimport { promisify } from 'node:util';\nimport psTree from 'ps-tree';\n\nimport { synchronized } from '@dxos/async';\nimport { Context } from '@dxos/context';\nimport { invariant } from '@dxos/invariant';\nimport { LockFile } from '@dxos/lock-file';\nimport { log } from '@dxos/log';\n\nimport { waitForLockAcquisition, waitForLockRelease } from './utils';\n\nexport type DaemonInfo = {\n  pid: number;\n  command: string;\n  args: string[];\n  cwd: string;\n  timestamp: number;\n};\n\nexport type ProcessInfo = WatchDogParams & {\n  pid?: number;\n  timestamp?: number;\n  restarts?: number;\n  running?: boolean;\n};\n\nexport type Lock = {\n  lockFile: string; // Path to lock file\n};\n\nexport type Logs = {\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\nexport type ChildParams = {\n  uid: string; // Unique identifier for this instance\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 type WatchDogParams = ChildParams & Lock & Logs;\n\nexport class WatchDog {\n  private _lock?: FileHandle;\n  private _child?: ChildProcessWithoutNullStreams;\n  private _restarts = 0;\n  private _processCtx?: Context;\n\n  constructor(private readonly _params: WatchDogParams) {}\n\n  @synchronized\n  async start() {\n    await this._acquireLock();\n    this._log('Lock acquired.');\n    const { cwd, shell, env, command, args } = { cwd: process.cwd(), ...this._params };\n    invariant(command, 'Command is not defined.');\n\n    this._log(`Spawning process ${command} ${args?.join(' ')}`);\n    this._child = spawn(command, args, { cwd, shell, env, stdio: 'pipe' });\n    this._processCtx = new Context();\n\n    const childInfo: ProcessInfo = {\n      pid: process.pid,\n      timestamp: Date.now(),\n      restarts: this._restarts,\n      ...this._params,\n    };\n\n    writeFileSync(this._params.lockFile, JSON.stringify(childInfo, undefined, 2), { encoding: 'utf-8' });\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\n    // Setup restart handler.\n    {\n      const restartHandler = async (code: number, signal: number | NodeJS.Signals) => {\n        if (code && code !== 0) {\n          this._err(`Died unexpectedly with exit code ${code} (signal: ${signal}).`);\n          await this.restart();\n        }\n      };\n\n      this._child.on('close', restartHandler);\n\n      // We should unsubscribe from the event when the process is killed by us to not try to restart it.\n      this._processCtx.onDispose(() => {\n        this._child!.off('close', restartHandler);\n      });\n    }\n\n    this._child.on('close', (code: number, signal: number | NodeJS.Signals) => {\n      this._log(`Stopped with exit code ${code} (signal: ${signal}).`);\n    });\n\n    invariant(this._child.pid, 'Child process has no pid.');\n    this._log(`Started with pid ${this._child.pid}.`);\n  }\n\n  /**\n   * Sends SIGINT to the child process and the tree it spawned (if `killTree` param is `true`).\n   */\n  @synchronized\n  async stop() {\n    if (!this._child) {\n      return;\n    }\n\n    await this._killWithSignal('SIGKILL');\n\n    await this._releaseLock();\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    await this._releaseLock();\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._processCtx, 'Process context is not defined.');\n    await this._processCtx.dispose();\n\n    // Kill child process tree.\n    if (this._params.killTree) {\n      if (process.platform !== 'win32') {\n        invariant(this._child?.pid, 'Child process has no pid.');\n        const children = await promisify(psTree)(this._child.pid);\n        children\n          .map((p) => p.PID)\n          .forEach((tpid) => {\n            invariant(tpid, 'Process id is not defined.');\n            process.kill(Number(tpid), signal);\n          });\n      }\n    }\n\n    invariant(this._child?.pid, 'Child process has no pid.');\n    this._child.kill(signal);\n    this._child = undefined;\n  }\n\n  private async _acquireLock() {\n    if (await LockFile.isLocked(this._params.lockFile)) {\n      throw new Error('Lock file is already locked.');\n    }\n    this._lock = await LockFile.acquire(this._params.lockFile);\n    await waitForLockAcquisition(this._params.lockFile);\n  }\n\n  private async _releaseLock() {\n    invariant(this._lock, 'Lock is not defined.');\n\n    await LockFile.release(this._lock);\n    await waitForLockRelease(this._params.lockFile);\n\n    this._lock = 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", "import_lock_file", "LOCK_TIMEOUT", "LOCK_CHECK_INTERVAL", "waitForLockAcquisition", "lockFile", "waitForCondition", "condition", "LockFile", "isLocked", "timeout", "LOCK_TIMEOUT", "interval", "LOCK_CHECK_INTERVAL", "error", "Error", "waitForLockFileBeingFilledWithInfo", "readFileSync", "encoding", "includes", "waitForLockRelease", "LOCK_FILE_NAME", "DaemonManager", "constructor", "_rootPath", "existsSync", "join", "mkdirSync", "recursive", "_getConfigFiles", "uid", "defaultConfigDir", "lockFile", "logFile", "errFile", "start", "params", "invariant", "command", "watchDogParams", "dirname", "LockFile", "isLocked", "Error", "unlinkSync", "watchdogPath", "pkgUp", "sync", "cwd", "__dirname", "watchDog", "fork", "JSON", "stringify", "detached", "on", "code", "signal", "log", "error", "waitForLockAcquisition", "waitForLockFileBeingFilledWithInfo", "disconnect", "unref", "getInfo", "stop", "force", "processInfo", "parse", "readFileSync", "encoding", "process", "kill", "pid", "err", "name", "includes", "message", "waitForLockRelease", "list", "uids", "readdir", "filter", "startsWith", "Promise", "all", "map", "files", "info", "running", "isRunning", "import_node_child_process", "import_node_fs", "import_async", "import_invariant", "import_lock_file", "import_log", "WatchDog", "constructor", "_params", "_restarts", "start", "_acquireLock", "_log", "cwd", "shell", "env", "command", "args", "process", "invariant", "join", "_child", "spawn", "stdio", "_processCtx", "Context", "childInfo", "pid", "timestamp", "Date", "now", "restarts", "writeFileSync", "lockFile", "JSON", "stringify", "undefined", "encoding", "stdout", "on", "data", "String", "stderr", "_err", "restartHandler", "code", "signal", "restart", "onDispose", "off", "stop", "_killWithSignal", "_releaseLock", "kill", "maxRestarts", "log", "dispose", "killTree", "platform", "children", "promisify", "psTree", "map", "p", "PID", "forEach", "tpid", "Number", "LockFile", "isLocked", "Error", "_lock", "acquire", "waitForLockAcquisition", "release", "waitForLockRelease", "message", "logFile", "flag", "errFile", "synchronized"]
+}

package/dist/lib/node/meta.json

@@ -0,0 +1 @@
+{"inputs":{"packages/common/phoenix/src/defs.ts":{"bytes":844,"imports":[],"format":"esm"},"packages/common/phoenix/src/utils.ts":{"bytes":4044,"imports":[{"path":"node:fs","kind":"import-statement","external":true},{"path":"@dxos/async","kind":"import-statement","external":true},{"path":"@dxos/lock-file","kind":"import-statement","external":true},{"path":"packages/common/phoenix/src/defs.ts","kind":"import-statement","original":"./defs"}],"format":"esm"},"packages/common/phoenix/src/daemon-manager.ts":{"bytes":15641,"imports":[{"path":"node:child_process","kind":"import-statement","external":true},{"path":"node:fs","kind":"import-statement","external":true},{"path":"node:fs/promises","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/lock-file","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":22416,"imports":[{"path":"node:child_process","kind":"import-statement","external":true},{"path":"node:fs","kind":"import-statement","external":true},{"path":"node:util","kind":"import-statement","external":true},{"path":"ps-tree","kind":"import-statement","external":true},{"path":"@dxos/async","kind":"import-statement","external":true},{"path":"@dxos/context","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/lock-file","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":1006,"imports":[{"path":"packages/common/phoenix/src/daemon-manager.ts","kind":"import-statement","original":"./daemon-manager"},{"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":20862},"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:fs/promises","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/lock-file","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":"@dxos/lock-file","kind":"require-call","external":true},{"path":"node:child_process","kind":"require-call","external":true},{"path":"node:fs","kind":"require-call","external":true},{"path":"node:util","kind":"require-call","external":true},{"path":"ps-tree","kind":"require-call","external":true},{"path":"@dxos/async","kind":"require-call","external":true},{"path":"@dxos/context","kind":"require-call","external":true},{"path":"@dxos/invariant","kind":"require-call","external":true},{"path":"@dxos/lock-file","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":159},"packages/common/phoenix/src/daemon-manager.ts":{"bytesInOutput":4716},"packages/common/phoenix/src/utils.ts":{"bytesInOutput":1027},"packages/common/phoenix/src/defs.ts":{"bytesInOutput":54},"packages/common/phoenix/src/watchdog.ts":{"bytesInOutput":6674}},"bytes":14487}}}

package/dist/types/src/daemon-manager.d.ts

@@ -0,0 +1,17 @@
+import { ChildParams, Logs, ProcessInfo } from './watchdog';
+/**
+ * Params to start a daemon.
+ * User have no control over the lock file.
+ */
+export type StartParams = ChildParams & Partial<Logs>;
+export declare class DaemonManager {
+    private readonly _rootPath;
+    constructor(_rootPath: string);
+    private _getConfigFiles;
+    start(params: StartParams): Promise<ProcessInfo>;
+    stop(uid: string, force?: boolean): Promise<ProcessInfo>;
+    list(): Promise<ProcessInfo[]>;
+    getInfo(uid: string): Promise<ProcessInfo>;
+    isRunning(uid: string): Promise<boolean>;
+}
+//# sourceMappingURL=daemon-manager.d.ts.map

package/dist/types/src/daemon-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-manager.d.ts","sourceRoot":"","sources":["../../../src/daemon-manager.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,WAAW,EAAE,IAAI,EAAQ,WAAW,EAAkB,MAAM,YAAY,CAAC;AAIlF;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAEtD,qBAAa,aAAa;IACZ,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,EAAE,MAAM;IAM9C,OAAO,CAAC,eAAe;IAYjB,KAAK,CAAC,MAAM,EAAE,WAAW;IA2CzB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO;IAoBjC,IAAI,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAU9B,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAgB1C,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAI/C"}

package/dist/types/src/daemon-manager.test.d.ts

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

package/dist/types/src/daemon-manager.test.d.ts.map

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

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

@@ -0,0 +1,4 @@
+export declare const LOCK_TIMEOUT = 1000;
+export declare const LOCK_CHECK_INTERVAL = 50;
+export declare const DAEMON_START_TIMEOUT = 10000;
+//# 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,oBAAoB,QAAS,CAAC"}

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

@@ -0,0 +1,3 @@
+export * from './daemon-manager';
+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,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC"}

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 waitForLockAcquisition: (lockFile: string) => Promise<boolean>;
+export declare const waitForLockFileBeingFilledWithInfo: (lockFile: string) => Promise<boolean>;
+export declare const waitForLockRelease: (lockFile: 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":"AAWA,eAAO,MAAM,sBAAsB,aAAoB,MAAM,qBAMzD,CAAC;AAEL,eAAO,MAAM,kCAAkC,aAAoB,MAAM,qBAMrE,CAAC;AAEL,eAAO,MAAM,kBAAkB,aAAoB,MAAM,qBAMrD,CAAC"}

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

@@ -0,0 +1,56 @@
+/// <reference types="node" />
+export type DaemonInfo = {
+    pid: number;
+    command: string;
+    args: string[];
+    cwd: string;
+    timestamp: number;
+};
+export type ProcessInfo = WatchDogParams & {
+    pid?: number;
+    timestamp?: number;
+    restarts?: number;
+    running?: boolean;
+};
+export type Lock = {
+    lockFile: string;
+};
+export type Logs = {
+    logFile: string;
+    errFile: string;
+};
+export type ChildParams = {
+    uid: string;
+    maxRestarts?: number | undefined;
+    killTree?: boolean | undefined;
+    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;
+}
+//# 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":";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"}

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,36 @@
+{
+  "name": "@dxos/phoenix",
+  "version": "0.1.58-main.0e9c99e",
+  "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": {
+    "fs-extra": "^8.1.0",
+    "pkg-up": "^3.1.0",
+    "ps-tree": "^1.2.0",
+    "@dxos/async": "0.1.58-main.0e9c99e",
+    "@dxos/context": "0.1.58-main.0e9c99e",
+    "@dxos/invariant": "0.1.58-main.0e9c99e",
+    "@dxos/keys": "0.1.58-main.0e9c99e",
+    "@dxos/lock-file": "0.1.58-main.0e9c99e",
+    "@dxos/log": "0.1.58-main.0e9c99e",
+    "@dxos/node-std": "0.1.58-main.0e9c99e",
+    "@dxos/util": "0.1.58-main.0e9c99e"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^9.0.4",
+    "@types/node": "^18.11.9",
+    "@types/ps-tree": "^1.1.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/daemon-manager.test.ts

@@ -0,0 +1,74 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+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';
+
+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.skip('start/stop detached watchdog', async () => {
+    const uid = `test-${PublicKey.random().toHex()}`;
+    const root = join(TEST_DIR, uid);
+    afterTest(() => {
+      fse.removeSync(root);
+    });
+
+    // Start
+    {
+      const manager = new DaemonManager(root);
+      const params = await manager.start({
+        uid,
+        command: 'node',
+        args: ['-e', `(${neverEndingProcess.toString()})()`],
+        maxRestarts: 0,
+      });
+
+      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 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 params = await manager.stop(uid);
+
+      await waitForExpect(() => {
+        const logs = readFileSync(params.logFile, { encoding: 'utf-8' });
+        expect(logs).to.contain('Stopped with exit code');
+      }, 1000);
+    }
+  });
+});

package/src/daemon-manager.ts

@@ -0,0 +1,138 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { fork } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, unlinkSync } from 'node:fs';
+import { readdir } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import pkgUp from 'pkg-up';
+
+import { invariant } from '@dxos/invariant';
+import { LockFile } from '@dxos/lock-file';
+import { log } from '@dxos/log';
+
+import { waitForLockAcquisition, waitForLockFileBeingFilledWithInfo, waitForLockRelease } from './utils';
+import { ChildParams, Logs, Lock, ProcessInfo, WatchDogParams } from './watchdog';
+
+const LOCK_FILE_NAME = 'lockfile';
+
+/**
+ * Params to start a daemon.
+ * User have no control over the lock file.
+ */
+export type StartParams = ChildParams & Partial<Logs>;
+
+export class DaemonManager {
+  constructor(private readonly _rootPath: string) {
+    if (!existsSync(join(_rootPath, 'profile'))) {
+      mkdirSync(join(_rootPath, 'profile'), { recursive: true });
+    }
+  }
+
+  private _getConfigFiles(uid: string): Logs & Lock {
+    const defaultConfigDir = join(this._rootPath, 'profile', uid);
+    if (!existsSync(defaultConfigDir)) {
+      mkdirSync(defaultConfigDir, { recursive: true });
+    }
+    return {
+      lockFile: join(defaultConfigDir, LOCK_FILE_NAME),
+      logFile: join(defaultConfigDir, 'file.log'),
+      errFile: join(defaultConfigDir, 'err.log'),
+    };
+  }
+
+  async start(params: StartParams) {
+    invariant(params.command, 'command is required');
+    const watchDogParams: WatchDogParams = {
+      ...this._getConfigFiles(params.uid),
+      ...params,
+    };
+
+    {
+      // Create log folders.
+      mkdirSync(dirname(watchDogParams.logFile), { recursive: true });
+      mkdirSync(dirname(watchDogParams.errFile), { recursive: true });
+    }
+
+    {
+      // Clear stale lock file if process is not running.
+      if (await LockFile.isLocked(watchDogParams.lockFile)) {
+        throw new Error('Lock file is already locked.');
+      }
+      unlinkSync(watchDogParams.lockFile);
+    }
+
+    const watchdogPath = join(dirname(pkgUp.sync({ cwd: __dirname })!), 'bin', 'watchdog');
+
+    const watchDog = fork(watchdogPath, [JSON.stringify(watchDogParams)], {
+      detached: true,
+      cwd: __dirname,
+    });
+
+    watchDog.on('exit', (code, signal) => {
+      if (code && code !== 0) {
+        log.error('Monitor died unexpectedly', { code, signal });
+      }
+    });
+
+    await waitForLockAcquisition(watchDogParams.lockFile);
+    await waitForLockFileBeingFilledWithInfo(watchDogParams.lockFile);
+
+    watchDog.disconnect();
+    watchDog.unref();
+
+    return this.getInfo(params.uid);
+  }
+
+  async stop(uid: string, force?: boolean) {
+    const lockFile = this._getConfigFiles(uid).lockFile;
+    const processInfo = JSON.parse(readFileSync(lockFile, { encoding: 'utf-8' }));
+    try {
+      if (force) {
+        process.kill(processInfo.pid, 'SIGKILL');
+      } else {
+        process.kill(processInfo.pid, 'SIGINT');
+      }
+    } catch (err) {
+      invariant(err instanceof Error, 'Invalid error type.');
+      if (!err.name.includes('ESRCH') && !err.message.includes('ESRCH')) {
+        throw err;
+      }
+    }
+    await waitForLockRelease(lockFile);
+
+    return this.getInfo(uid);
+  }
+
+  async list(): Promise<ProcessInfo[]> {
+    const uids = (await readdir(join(this._rootPath, 'profile'))).filter((uid) => !uid.startsWith('.'));
+
+    return Promise.all(
+      uids.map(async (uid) => {
+        return this.getInfo(uid);
+      }),
+    );
+  }
+
+  async getInfo(uid: string): Promise<ProcessInfo> {
+    const files = this._getConfigFiles(uid);
+
+    let info: ProcessInfo = { running: await LockFile.isLocked(files.lockFile), uid, ...files };
+    if (existsSync(files.lockFile)) {
+      try {
+        info = {
+          ...info,
+          ...JSON.parse(readFileSync(files.lockFile, { encoding: 'utf-8' })),
+        };
+      } catch (err) {}
+    }
+
+    return info;
+  }
+
+  async isRunning(uid: string): Promise<boolean> {
+    const lockFile = this._getConfigFiles(uid).lockFile;
+    return LockFile.isLocked(lockFile);
+  }
+}

package/src/defs.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+export const LOCK_TIMEOUT = 1_000;
+export const LOCK_CHECK_INTERVAL = 50;
+export const DAEMON_START_TIMEOUT = 10_000;

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 './daemon-manager';
+export * from './watchdog';

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,34 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { readFileSync } from 'node:fs';
+
+import { waitForCondition } from '@dxos/async';
+import { LockFile } from '@dxos/lock-file';
+
+import { LOCK_CHECK_INTERVAL, LOCK_TIMEOUT } from './defs';
+
+export const waitForLockAcquisition = async (lockFile: string) =>
+  waitForCondition({
+    condition: async () => await LockFile.isLocked(lockFile),
+    timeout: LOCK_TIMEOUT,
+    interval: LOCK_CHECK_INTERVAL,
+    error: new Error('Lock file is not being acquired.'),
+  });
+
+export const waitForLockFileBeingFilledWithInfo = async (lockFile: 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.'),
+  });
+
+export const waitForLockRelease = async (lockFile: string) =>
+  waitForCondition({
+    condition: async () => !(await LockFile.isLocked(lockFile)),
+    timeout: LOCK_TIMEOUT,
+    interval: LOCK_CHECK_INTERVAL,
+    error: new Error('Lock file is not being released.'),
+  });

package/src/watchdog.test.ts

@@ -0,0 +1,40 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { expect } from 'chai';
+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';
+import { WatchDog } from './watchdog';
+
+describe('WatchDog', () => {
+  test('Start/stop process', async () => {
+    const runId = Math.random();
+    const lockFile = join(TEST_DIR, `lock-${runId}.lock`);
+    const logFile = join(TEST_DIR, `file-${runId}.log`);
+    const errFile = join(TEST_DIR, `err-${runId}.log`);
+    afterTest(() => clearFiles(lockFile, logFile, errFile));
+
+    const watchDog = new WatchDog({
+      uid: 'test',
+      command: 'node',
+      args: ['-e', `(${neverEndingProcess.toString()})()`],
+      lockFile,
+      logFile,
+      errFile,
+    });
+
+    expect(await asyncTimeout(LockFile.isLocked(lockFile), 1000)).to.be.false;
+    await watchDog.start();
+
+    expect(await asyncTimeout(LockFile.isLocked(lockFile), 1000)).to.be.true;
+
+    await watchDog.stop();
+    expect(await asyncTimeout(LockFile.isLocked(lockFile), 1000)).to.be.false;
+  });
+});

package/src/watchdog.ts

@@ -0,0 +1,226 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { ChildProcessWithoutNullStreams, spawn } from 'node:child_process';
+import { 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;
+};
+
+export type ProcessInfo = WatchDogParams & {
+  pid?: number;
+  timestamp?: number;
+  restarts?: number;
+  running?: boolean;
+};
+
+export type Lock = {
+  lockFile: string; // Path to lock 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
+  //
+  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 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._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));
+    });
+    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._log(`Stopped with exit code ${code} (signal: ${signal}).`);
+    });
+
+    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;
+    }
+
+    await this._killWithSignal('SIGKILL');
+
+    await this._releaseLock();
+  }
+
+  /**
+   * 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');
+
+    await this._releaseLock();
+  }
+
+  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._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+',
+      encoding: 'utf-8',
+    });
+  }
+
+  private _err(message: string | Uint8Array) {
+    this._log(message);
+    writeFileSync(this._params.errFile, message + '\n', {
+      flag: 'a+',
+      encoding: 'utf-8',
+    });
+  }
+}